6.泛型和通配符

泛型

1 泛型概述

1.1 为什么要有泛型

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

例如：Collection,List,ArrayList这个参数就是类型参数，即泛型。

1.2 泛型的概念

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

• 1.5以后，java引入了“参数化类型(Parameterized type)”的概念，允许我们在创建集合时在指定集合元素的类型，例如List
• 1.5改写了集合框架中的全部接口和类，为了这些接口，类增加了泛型的支持，从而可以在声明集合变量，创建集合对象的时候传入类型实参。

1.3 使用的注意事项

• 集合接口或者集合类在jdk5时都修改为带参数的结构。
• 实例化集合类时，可以指明具体的泛型类型
• 指明完之后在集合类或者接口中凡是定义类或者接口时，内部结构（比如：方法，构造器，属性）就已经确定。
• 泛型类型必须是个类，类型实参不能写基本数据类型，要写其包装类。
• 如果没有指明泛型的类型，默认类型为java.lang.Object类型。

1.4 如何自定义泛型结构

1.4.1 泛型类和泛型接口

• 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>

• 泛型类的构造器如下：public GenericClass(){ }。

  ​ 而下面是错误的：public GenericClass(){ }

• 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

• 泛型不同的引用不能相互赋值。

• 尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

• 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。

  • 经验：泛型要使用要么都用。要不用，都不要用。

• 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

• jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();

• 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

• 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

• 异常类不能是泛型的

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

  ​ 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

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

  子类不保留父类的泛型：按需实现，没有类型，擦除具体类型

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

  ​ 全部保留

  ​ 部分保留

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

1.4.2 泛型方法

在方法中出现了泛型的结构，泛型参数。与泛型类的泛型参数没有关系，甚至和类是不是泛型都没有关系。

2 自定义泛型类

2.1 自定义泛型类

/**
 *自定义泛型类
 * @param <T>:类的泛型
 */
class Order<T>{
    String orderName;
    int orderId;
    T t;
    public Order(){

    }
    public Order(String name,int orderId,T t){
        this.orderName=name;
        this.orderId=orderId;
        this.t=t;
    }
    public T getT(){
        return t;
    }
    public void setT(T t){
        this.t=t;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", t=" + t +
                '}';
    }
    //public List<E> copyFromArrayToList(E[] a)==>编译器认为有个类叫做E,需要假如泛型参数
    public static  <E> List<E> copyFromArrayToList(E[] arr){
        ArrayList<E> es = new ArrayList<>();
        for (E e:arr
             ) {
            es.add(e);
        }
        return es;
    }
}

2.2 在继承方面的体现

ArrayList<Object> list = new ArrayList<>();
ArrayList<String> strings1 = new ArrayList<>();
//list和strings1不具备子父类关系，是并列关系。
//list=strings1;==>编译不通过。
List<String> strings2 = new ArrayList<>();
strings2=strings1;//可以实现。

结论：类A是类B的父类，G(A)和G(B)不是子父类关系，是并列关系。

​ A(T)=B(T);是可以的

3 通配符的使用

1）解决当方法中只有泛型不一致导致的我们需要重载方法的问题。

即G(A)和G(B)不是子父类关系，是并列关系。引入通配符：？

两者公共的父类是G<?>

2）G<?>中不可以添加数据，除了添加null之外。但是允许读取数据

@Test
public void test01(){
    List<Object> list1=null;
    List<String> list2=null;
    list1=new ArrayList<>();
    list1.add("张三");
    list1.add("李四");
    List<?> list=null;
    System.out.println(list); //null
    list=list2;
    //System.out.println(list);  //null
    list=list1;
    //只允许添加null
    list.add(null);
    //允许进行读取数据
    print(list);

}

3）有限制的通配符

 <? extends Number> ( 无穷小 , Number]

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

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

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

​	 <? extends Comparable>

​			只允许泛型为实现Comparable接口的实现类的引用调用

@Test
public void test02(){
    List<? extends Person> list1=new ArrayList<>();
    List<? super Person> list2=new ArrayList<>();

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

    list1=list3;
    list1=list4;
    //list1=list5;
    //list2=list3;
    list2=list4;
    list2=list5;
    //读取数据的测试
    //可以Person或者Object来进行接收
    Person person= list1.get(0);
    //只可以写Object
    Object object = list2.get(0);
    //写入数据的测试
    //不可以赋值，编译不通过。
    //list1.add(new Student());
    //可以赋值，只能放Person()。
    list2.add(new Person());
    list2.add(new Student());
}