Java泛型

1、泛型的概念

• 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
• 从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List，这表明该List只能保存字符串类型的对象。
• JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

2、自定义泛型

2.1 自定义泛型类/接口

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内，比如：<E1,E2,E3>。
• 泛型类的构造器如下：public GenericClass(){}。
• 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
• 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
• 泛型不同的引用不能相互赋值。

ArrayList<String> list1 = null;
ArrayList<Integer> list2 = new ArrayList<Integer>();
//泛型不同的引用不能相互赋值。
//list1 = list2;

• 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
• 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
• jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>()。
• 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

public class Order<T> {

    String orderName;
    int orderId;
    T orderT;
    
    //静态方法中不能使用类的泛型。
    //public static void show(T orderT){
    //    System.out.println(orderT);
    //}
}

• 异常类不能是泛型的。

//异常类不能声明为泛型类
//public class MyException<T> extends Exception{
//}

public class Order<T> {

    String orderName;
    int orderId;
    T orderT;

    public void show(){
//编译不通过
//        try{
//
//
//        }catch(T t){
//
//        }
    }
}

• 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]。

public class Order<T> {
    String orderName;
    int orderId;
    T orderT;

    public Order(){
        //编译不通过
        //T[] arr = new T[10];
        //编译通过，为了保证运行不报错，需要使Object数组中保存的是T或者T的子类的对象。
        T[] arr = (T[]) new Object[10];
    }
}

• 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

  • 子类不保留父类的泛型：按需实现。

    • 没有类型则擦除。
    • 具体类型。

  • 子类保留父类的泛型：泛型子类.

    • 全部保留。
    • 部分保留。

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

更复杂地：

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

• 虽然类A是类B的父类，但是G 和G二者不具备子父类关系，二者是并列关系。

List<Object> list1 = null;
List<String> list2 = new ArrayList<String>();
//此时的list1和list2的类型不具有子父类关系
//编译不通过
list1 = list2;

• 类A是类B的父类，A 是 B 的父类。

Object[] arr1 = null;
String[] arr2 = null;
//编译通过
arr1 = arr2;

2.2 自定义泛型方法

• 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。

public class Order<T> {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型
    T orderT;

    public Order(){
        //编译不通过
        //T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    //不是泛型方法
    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没有关系。
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> list = new ArrayList<>();
        for(E e : arr){
            list.add(e);
        }
        return list;
    }
}

3、通配符

• 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
• 类A是类B的父类，G和G是没有关系的，二者共同的父类是：G<?>。

  @Test
  public void test(){
      List<Object> list1 = null;
      List<String> list2 = null;
//此时List<?> list相当于List<Object>和List<String>的通用父类
      List<?> list = null;
      list = list1;
      list = list2;
  }

  public void print(List<?> list){
      Iterator<?> iterator = list.iterator();
      while(iterator.hasNext()){
          Object obj = iterator.next();
          System.out.println(obj);
      }
  }

• 对于List<?>就不能向其内部添加数据；允许读取数据，读取的数据类型为Object。

@Test
public void test(){
    List<?> list = null;
    List<String> list2 = new ArrayList<>();
    list2.add("AA");
    list2.add("BB");
    list2.add("CC");
    list = list2;

    //添加(写入)：对于List<?>就不能向其内部添加数据。
    //除了添加null之外。
    //list.add("DD");
    //list.add('?');
    list.add(null);

    //获取(读取)：允许读取数据，读取的数据类型为Object。
    Object o = list.get(0);
    System.out.println(o);
}

• (无穷小 , Number]：只允许泛型为Number及Number子类的引用调用。 + G 可以作为G和G的父类，其中B是A的子类。
• [Number , 无穷大)：只允许泛型为Number及Number父类的引用调用。 + G 可以作为G和G的父类，其中B是A的父类。

@Test
public void test(){
    List<? extends Person> list1 = null;
    List<? super Person> list2 = null;

    List<Student> list3 = new ArrayList<Student>();
    List<Person> list4 = new ArrayList<Person>();
    List<Object> list5 = new ArrayList<Object>();

    //编译通过
    list1 = list3;
    list1 = list4;

    //编译不通过
    //list1 = list5;

    //编译通过
    list2 = list4;
    list2 = list5;

    //编译不通过
    //list2 = list3;

    //读取数据：
    list1 = list3;
    //最小只能是Person
    Person p = list1.get(0);
    //编译不通过
    //Student s = list1.get(0);

    list2 = list4;
    //只能是object
    Object obj = list2.get(0);
    //编译不通过
    //Person obj = list2.get(0);

    //写入数据：
    //编译不通过，因为如果？是比Student还小的对象，当new Student()后，无法将new Student()的引用赋值给？对象的引用。
    //list1.add(new Student());

    //编译通过，只能添加person及person的子类的对象。
    list2.add(new Person());
    list2.add(new Student());
}