JavaSE 笔记【十一】泛型

视频链接：Java零基础教程

为什么要有泛型？

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK 1.5 之前只能把元素类型设计为Object，JDK 1.5之后使用泛型解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如果管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection< E>，List< E>，ArrayList< E> 这个< E>就是类型参数，即泛型

泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创造对象时）确定（即传入实际的类型参数，也称为类型实参）

从JDK 1.5 以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们再创建集合时再指定集合元素的类型，比如：List< String>，这表明该List只能保存字符串类型的对象
JDK 1.5 改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参

泛型的使用

总结：
① 集合接口或集合类在jdk 5.0 时都修改为带泛型的结构
② 在实例化集合类时，可以指明具体的泛型类型
③ 指明完之后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型 比如：add(E e) ----> 实例化后：add(Integer e)
④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
⑤ 如果实例化时没有指定泛型的类型。默认类型为java.lang.Object类型

自定义泛型结构

自定义泛型结构：泛型类、泛型接口、泛型方法

class Order<T> {
  private Long id;
  private String name;
  private T goods;

  public Order() {
  }

  public Order(Long id, String name, T goods) {
    this.id = id;
    this.name = name;
    this.goods = goods;
  }

  public T getGoods() {
    return goods;
  }

  public void setGoods(T goods) {
    this.goods = goods;
  }
}

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：< E1, E2, E3>
2. 泛型类的构造器如下：public GenericClass() {} 而下面是错误的：public GenericClass< E>() {}
3. 实例化后，操作原来泛型位置的接口必须与指定的泛型类型一致
4. 泛型不同的引用不能相互赋值。尽管在编译时ArrayList< String> 和 ArrayList< Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中
5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价与Object。经验：泛型要使用一路都用。要不用，一路都不要用
6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
7. jdk 1.7，泛型的简化操作：ArrayList< Fruit> flist = new ArrayList<>();
8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换
9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型
10. 异常类不能使用泛型的
11. 不能使用new E[]。但是可以：E[] elements = (E[] new Objcet[capacity]); 参考：ArraryList源码中声明：Object[] elementData，而非泛型参数类型数组
12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
    • 子类不保留子类的泛型：按需实现
      — 没有类型 擦除
      — 具体类型
    • 子类保留父类的泛型：泛型子类
      — 全部保留
      — 部分保留

    class Father<T1, T2> {}
    // 子类不保留父类的泛型
    // 1) 没有类型 擦除
    class Son1 extends Father {} // 等价于class Son extends Father<Object, Object> {}
    // 1) 具体类型
    class Son2 extends Father<Integer, String> {}
    // 子类保留父类的泛型
    // 1) 全部保留
    class Son3<T1, T2> extends Father<T1, T2> {}
    // 2) 部分保留
    class Son4<T2> extends Father<Integer, T2> {}
    

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

泛型方法

在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系，非泛型类中也可以有泛型方法
在泛型方法调用时，指明泛型参数的类型，所有泛型方法可以为static方法

// Collection
public interface Collection<E> extends Iterable<E> {
	<T> T[] toArray(T[] a); // 方法前面申明T，来说明T[]中的T不是 类 的类型
}

泛型在继承方面的体现

类A是类B的父类，但是 G< A> 和 G< B> 二者不具备子父类关系，二者是并列关系
补充：类A是类B的父类，A< G> 是 B< G> 的父类

Object obj = null;
String str = null;
obj = str; // √

Object[] arr1 = null;
String[] arr2 = null;
arr1 = arr2; // √

List<Object> list1 = null;
List<String> list2 = null;
list1 = list2; // 编译报错，此时的list1和list2不具备子父类关系

通配符的使用

类A是类B的父类，但是 G< A> 和 G< B> 是没有关系的，二者共同的父类是：G< ?>

List<Objcet> list1 = null;
List<String> list2 = null;
List<?> list = null;
list = list1; // √
list = list2; // √
List<String> list3 = new ArrayList<>();
list3.add("AA");
list3.add("BB");
list = list3; // √
// 添加：对于List<?> 就不能向其内部添加数据，除了null
list.add("CC"); // 编译报错
list.add(null); // √
// 获取：允许读取数据，读取的数据类型为Object
Object o = list.get(0); // √

有限制条件的通配符

通配符指定上限
上限 extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=，如List<? extends Number>不可添加非null
通配符指定上限
上限 super：使用时指定的类型不能小于操作的类，即>=，如List<? super Number>可添加非null，Number类型及其子类对象

举例：

• <? extends Number> (无穷小，Number]

只允许泛型为Number及Number子类的引用调用

• <? super Number> [Number, 无穷大)

只允许泛型为Number及Number父类的引用调用