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

2020-11-23 0 By admin

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

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());
  }
}