Java 泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

• 可以在类或方法中预支地使用未知的类型
• 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
• Java的数据类型一般都是在定义时就需要确定，这种强制的好处就是类型安全，不会出现像弄一个ClassCastException的数据给jvm，数据安全那么执行的class就会很稳定。但是假如说我不知道这个参数要传什么类型的，因为公司需求在变，如果写死的那就只能便以此需求就改一次，很麻烦。sun公司也注意到这个问题，这样会让代码的灵活性降低，他们就研究出了泛型

泛型由来

集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

import java.util.*;
public class GenericDemo {
  public static void main(String[] args) {
    Collection coll = new ArrayList();
    coll.add("abc");
    coll.add("itcast");
    coll.add(5);// 由于集合没有做任何限定，存放其他类型(可存放任何类型)
    Iterator it = coll.iterator();
    while (it.hasNext()) {
      // 需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
      String str = (String) it.next();
      System.out.println(str.length());
    }
  }
}

程序在运行时发生了问题 java.lang.ClassCastException,这样我们使用API的时候也变得更为简洁，并得到了编译时期的语法检查。,在JDK5之后，新增了泛型(Generic)语法，让你在设计API时可以指定类或方法支持泛型，
⚠️tips:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型

假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？答案是可以使用 Java 泛型。使用 Java 泛型的概念，我们可以写一个泛型方法来对一个对象数组排序。然后，调用该泛型方法来对整型数组、浮点数数组、字符串数组等进行排序。

泛型初识

什么是泛型，可以字面理解就是一个泛泛的类型，他是不确定的，在Java代码编译的时候用泛型是不会出错的，而在运行期时就会报错，说你这种第一是不合理的。这是为什么呢。因为为了提高灵活性，就在编译时期将条件放宽，但是泛型一定要在运行的时候告诉jvm你给我的数据到底是什么类型的，否则jvm会是懵逼的。所以泛型的好处就是将类型的灵活性提高，也只是在Java语法的基础上提高，不过泛型还是比较实用的

何时使用泛型

泛型的应用场景就是应用在模型（可以理解为存储数据的盒子），我为了这个盒子适用更多的地方我就用将需要存入的数据用一个泛型表示，当然可以传入多值。如果是相同类型的对象就用一个泛型的数组比较好，学过集合的小伙伴应该都知道，没学过的那你应该补补课了

泛型的语法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。 注意类型参数只能代表引用型类型 ，不能是原始类型（像int,double,char的等） ```java //定义格式 修饰符 class 类名<代表泛型的变量>{}

//比如API中的ArrayList集合 public class ArrayList{ // extends Object可以省略 E name; public boolean add(E name){ this.name = name } }

//使用 ArrayList list = new ArrayList();

```java
public class GenericMethodTest {
  // 泛型方法 printArray
  public static <E> void printArray(E[] inputArray) {
    // 输出数组元素
    for (E element : inputArray) {
      System.out.printf("%s ", element);
    }
    System.out.println();
  }
  public static void main(String args[]) {
    // 创建不同类型数组： Integer, Double 和 Character
    Integer[] intArray = { 1, 2, 3, 4, 5 };
    Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
    Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
    System.out.println("整型数组元素为:");
    printArray(intArray); // 传递一个整型数组
    System.out.println("\n双精度型数组元素为:");
    printArray(doubleArray); // 传递一个双精度型数组
    System.out.println("\n字符型数组元素为:");
    printArray(charArray); // 传递一个字符型数组
  }
}
/* 
整型数组元素为:
1 2 3 4 5 
双精度型数组元素为:
1.1 2.2 3.3 4.4 
字符型数组元素为:
H E L L O  
*/

有界的类型参数

可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。
要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界。
下面的例子演示了”extends”如何使用在一般意义上的意思”extends”（类）或者”implements”（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

public class MaximumTest {
  // 比较三个值并返回最大值
  public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
    T max = x; // 假设x是初始最大值
    if (y.compareTo(max) > 0) { max = y; } // y 更大
    if (z.compareTo(max) > 0) { max = z; } // 现在 z 更大
    return max; // 返回最大对象
  }

  public static void main(String args[]) {
    System.out.printf("%d, %d 和 %d 中最大的数为 %d\n\n", 3, 4, 5, maximum(3, 4, 5));
    System.out.printf("%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n", 6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));
    System.out.printf("%s, %s 和 %s 中最大的数为 %s\n", "pear", "apple", "orange", maximum("pear", "apple", "orange"));
  }
}

/* 
编译以上代码，运行结果如下所示：
3, 4 和 5 中最大的数为 5
6.6, 8.8 和 7.7 中最大的数为 8.8
pear, apple 和 orange 中最大的数为 pear 
*/

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。
和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
如下实例演示了我们如何定义一个泛型类:

public class Box<T> {

  private T t;

  public void add(T t) {
    this.t = t;
  }

  public T get() {
    return t;
  }

  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();

    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));

    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}
/* 
编译以上代码，运行结果如下所示：
整型值为:10
字符串为:菜鸟教程
*/

类型通配符

1. 类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是List,List 等所有List<具体类型实参>的父类。不知道使用什么类型来接收的时候,此时可以使用 ? ```java import java.util.*;

public class GenericTest {

public static void main(String[] args) { List names = new ArrayList(); List ages = new ArrayList(); List numbers = new ArrayList();

names.add("icon");
ages.add(18);
numbers.add(314);

getData(names);
getData(ages);
getData(numbers);

}

// public static void getData(List data) { // System.out.println(“data :” + data.get(0)); // }

public static void getData(List<?> data) { System.out.println(“data :” + data.get(0)); } }

/ data :icon data :18 data :314 /

**解析:** 因为getData()方法的参数是List类型的，所以name，age，number都可以作为这个方法的实参，这就是通配符的作用

2. 类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型
```java
import java.util.*;

public class GenericTest {

  public static void main(String[] args) {
    List<String> name = new ArrayList<String>();
    List<Integer> age = new ArrayList<Integer>();
    List<Number> number = new ArrayList<Number>();

    name.add("icon");
    age.add(18);
    number.add(314);

    // getUperNumber(name);//1
    getUperNumber(age);// 2
    getUperNumber(number);// 3

  }

  public static void getData(List<?> data) {
    System.out.println("data :" + data.get(0));
  }

  public static void getUperNumber(List<? extends Number> data) {
    System.out.println("data :" + data.get(0));
  }
}

/* 
输出结果：
data :18
data :314 
*/

解析: 在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错

1. 类型通配符下限通过形如 List<? super Number>来定义，表示类型只能接受Number及其三层父类类型，如 Object 类型的实例

泛型的缺点或者为什么需要上、下边界

泛型的虽然强大，但是世界上任何东西东部是完美的。它也有缺陷。比如说我有一个盒子我想装苹果，但是我还可能想装香蕉那怎么办。那还不好说，在给一个参数不就行了，那十个呢，二十个呢。em….的确是。如果说我们想装的东西都属于一个类并且只要是这个类的子类就可以装。这个想法sun为我们想好了。那就是用上边界通配符。语法是 T是泛型，M是T的父类。我们就定义一个水果类（Fruit），盛装就容器就是盘子（Dish），现在我们就可以装任何水果了，不错吧！

上边界Java代码

public class Dish<T extends Fruit>{
  private T fruitChild;

  public Dish(T fruitChild){
    this.fruitChild = fruitChild;
  }

  public T getFruitChild(){
    return fruitChild;
  }

  public void setFruitChild(T f){
    this.fruitChild = f;
  }

  public static void main(String[] args){
    Dish dish = new Dish<apple>();
    Apple apple = new apple(); //apple must be Fruit child;
    dish.setFruitChild(apple);
    system.out.printf(dish.getFruitChild);
  }
}

下边界Java代码

public class Dish<T super Apple>{
  private T appleFather;

  public Dish(T appleFather){
    this.appleFather = appleFather;
  }

  public T getAppleFather(){
    return appleFather;
  }

  public void setAppleFather(T f){
    this.appleFather = f;
  }

  public static void main(String[] args){
    Dish dish = new Dish<Fruit>();
    Fruit fruit = new Fruit(); //fruit must be apple son;
    dish.setAppleFather(fruit);
    system.out.printf(dish.getAppleFather);
  }
}

什么是上边界通配符

当泛型T给定形如 的A类型到A类型任何子类的限制域，可以匹配任何在此限制域中的类型，此种表示叫上边界通配符

什么是下边界通配符

当泛型T给定形如 的A类型到A类型任何父类的限制域，可以匹配任何在此限制域中的类型，此种表示叫下边界通配符

上下边界通配符的缺点

上界<? extends T>不能往里存，只能往外取
因为编译器只知道传入的是T的子类，但具体是哪一个编译器不知道，他只标注了一个占位符，当？传过来时，他不知道这能不能和占位符匹配，所以set不了

下界<? super T>不影响往里存，但往外取只能放在Object对象里
因为下边界已经限制了？的粒度，他只可能是T本身或者是T的父类。我们想想，我想要一个T，你却返回给我一个比T小的Object，这样我们就因为精度损失而拿不到想要的数据了