泛型在继承上的体现【通配符】

一、引子：泛型中存在的继承情况

1.1、场景一

如果 B 是 A 的一个子类型（子类或者子接口），而 G 是具有泛型声明的类或接口，G<B> 并不是 G<A> 的子类型！二者是并列关系。
比如：String 是 Object 的子类，但是 List<String> 并不是 List<Object> 的子类。

  @Test
  public void test(){
    Object obj = null;
    String str = null;
    obj = str;
    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
//编译不通过
//  Date date = new Date();
//  str = date;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<String>();
//此时的list1和list2的类型不具有子父类关系
//编译不通过
//  list1 = list2;
/**
 * 反证法：
 *   假设list1 = list2;
 *   list1.add(123);导致混入非String的数据。出错。
 */
    show(list1);
    show2(list2);
  }
  public void show2(List<String> list){
  }
  public void show(List<Object> list){
  }

1.2、场景二：

如果 A 是 B 的父类，则 A<G> 是 B<G> 的父类；
AbstractList<String>、List<String>、ArrayList<String>是父子类的关系。

  public void test2(){
    AbstractList<String> list1 = null;
    List<String> list2 = null;
    ArrayList<String> list3 = null;
    list1 = list3;
    list2 = list3;
    List<String> list4 = new ArrayList<>();
  }

二、类型通配符 ?

场景三：
因为泛型没有继承关系，所以当需要用一个泛型引用不同的泛型实现时，泛型中写他们共同的父类是不行的。于是引入一个新的概念，叫做 [泛型通配符 ?]。

比如：List<?> ，Map<?,?>使用了类型通配符；List<?>是List、List等各种泛型List的父类。

public class GenericTest {
//类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>
  @Test
  public void test3(){
    List<Object> list1 = null;
    List<String> list2 = null;
    List<?> list = null;
    list = list1;
    list = list2;
    //编译通过
    print(list1);
    print(list2);
  }
  public void print(List<?> list){
    Iterator<?> iterator = list.iterator();
    while(iterator.hasNext()){
      Object obj = iterator.next();
      System.out.println(obj);
    }
  }
}

2.1、泛型通配符中的读写问题

1. 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
2. 写入list中的元素时，不行。因为我们不知道其中的元素类型，不能向其中添加对象。
3. 唯一的例外是null，它是所有类型的成员。

将任意元素加入到其中不是类型安全的：

- Collection<?> c = new ArrayList();
- c.add(new Object()); 
// 编译时错误因为我们不知道c的元素类型，我们不能向其中添加对象。
//add方法有类型参数E作为集合的元素类型。我们传给add的任何参数都必须是一个未知类型的子类。
//因为我们不知道那是什么类型，所以我们无法传任何东西进去。
- c.get(1)
我们可以调用get()方法并使用其返回值。返回值是一个未知的类型，但是我们知道，它总是一个Object。

三、有限制条件的通配符的使用

<?> 允许所有泛型的引用调用。

有时候，我们想要对可以调用的泛型做范围控制，这是就可以使用 extends 和 super 两个关键词。

3.1、通配符指定上限

extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

<?extends Number> (无穷小, Number]
只允许泛型为Number及Number子类的引用调用

<? extends Comparable>
只允许泛型为实现Comparable接口的实现类的引用调用

3.2、通配符指定下限

下限super：使用时指定的类型不能小于操作的类，即>=

<? super Number> [Number , 无穷大)
只允许泛型为Number及Number父类的引用调用

3.3、示例说明

public class GenericTest {
/**
 * ? extends A:
 *    G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类
 *
 * ? super A:
 *    G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类
 */
public void test4(){
    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>();

//extends 继承类和其子类的父类
    list1 = list3;
    list1 = list4;
//  list1 = list5;

//super 继承类和其父类的父类
//  list2 = list3;
    list2 = list4;
    list2 = list5;

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

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

//写入数据：
//编译不通过
//  list1.add(new Student());
//编译通过
    list2.add(new Person());
    list2.add(new Student());
  }
}