快速理解＜? extends T＞和＜? super T＞

在 Java 泛型中存在通配符的概念:

• <? extends T>:上界通配符(Upper Bounds Wildcards）

• <? super T>:下界通配符(Lower Bounds Wildcards)

通配符存在的意义

有类就会有继承，在开发中我们经常接触泛型，肯定希望在使用泛型的时候可以兼容其子类，但是在使用集合或者其他类似的情景时会出现问题。下面用集合例子模拟真实的需求:

A a = new B();
ArrayList<A> list= new ArrayList<B>(); // 报错

根据上面的代码，假设 B 继承 A，第一行代码是合法的，但是第二行代码编译器会直接红线报错，ArrayList<B> 无法赋值给 ArrayList<A>。这是因为编译器在确定 ArrayList 元素类型的时候不会考虑 A 和 B 的继承关系，编译器无法承认第二行代码是合法的。为了解决这个问题引入了通配符的概念。

Ps:该例子中用的是 ArrayList 做例子，但并不是只针对集合，是针对类似集合出现的问题的情景。

类继承关系图.png

根据上面的类的继承关系图，我们用 C 来观察，假设有下面两个 List:

List<? extends C> list1; // list1 的元素的类型只能是 C 和 C 的子类。
List<? super C> list2; // list2 的元素的类型只能是 C 和 C 的父类。

list1 和 list2 的类型区间:

ArrayList<B> b = new ArrayList<>();
ArrayList<C> c = new ArrayList<>();
ArrayList<D> d = new ArrayList<>();
// <? extends C>
list1 = b; // 报错
list1 = c;
list1 = d;
// <? super C>
list2 = b; 
list2 = c;
list2 = d; // 报错

注意: 编译器针对 <? extends C> 和 <? super C> 只关心与 C 有关的类继承关系，即只关心 C 的所有父类、 C 的所有子类和 C 本身的继承关系，即使 A 或者 B 存在其他子类编译器都不关心。

下面先认识 <? extends C> 和 <? super C> 的区别：

• <? extends C>

  • add(): 不可以加入任何元素(除了 null 因为 null 可以为任何类型)，编译器会红线报错，如:

    • /**
       * Required type: capture of ? extends C
       * Provided: B
       */
      // list1.add(new B());
      // list1.add(new C());
      // list1.add(new D());
      list1.add(null);
      

• get():返回的值的类型默认是 C ，如:

  • C c = list1.get(0);
    /**
     * 编译器不报错，但如果 list1 第0个元素是 E 或者 F 的话,
     * 运行时存在强制类型转换失败程序崩溃的风险
     * Exception in thread "main" java.lang.ClassCastException: 
     * E cannot be cast to D
     */
    D d1 = (D) list.get(0);
    

• <? super C>

  • add(): 只能添加类型为 C 和其子类类型的元素，如:

    • /**
       * Required type: capture of ? super C
       * Provided: B
       */
      // list2.add(new B()); // 报错
      list2.add(new C());
      

    list2.add(new D());
    list2.add(new E());
    list2.add(new F());

  • get():返回的值的类型默认是 Object，如:

    • Object object = list2.get(0);
      

简单来说就是 <? extends C> 上界为 C 类型范围粗略理解为 [ C , +∞ )，不允许添加除 null 的元素，get() 的元素类型默认是 C ,当然在知道集合元素类型的情况下通过强转程序是允许的；

<? super C> 下界为 C 类型范围粗略理解为 ( -∞ , C ]，允许添加 C 以及 C 的子类类型的元素，获取的元素类型是 Object

---

从编译器的角度理解上面的区别：

首先理解车的例子：单车是车的子类，单车有车的特性可以代表车，但是车不能代表单车。即类型向上兼容向下不兼容。

• <? extends C>
  • add() : 编译器只知道元素类型是 C 或 C 的子类，所以有可能是 C D E F 其中一个类型，为保证类型安全不能添加除了 null 以外的任何元素，即使是 C 本身也不行(车不能代表单车).
  • get() : 既然编译器不知道此时集合中的元素是 C D E F 的哪一个，返回类型只能是他们共同父类 C 类型.
• <? super C>
  • add() : 编译器只知道元素类型是 C 或者 C 的父类，所以有可能是 A B C 其中一个类型。编译器知道下界是 C ，根据类型向上兼容所以可以添加的元素是 C 以及 C 的子类(单车可以代表车).
  • get() : 既然编译器不确定集合类型是 A B C 的哪一种，返回类型只能是他们的共同父类 Object .

特点：<? extends C> 的 add() 被限制，<? super C> 的 get() 被限制

PECS 原则

<? extends C> 适合大量做获取操作的情景，<? super C> 适合大量做添加操作的情景。