Java泛型的＜? super T＞,＜? extend T＞的区别

悠悠 2024-04-07 12:45 102阅读 0赞

## ？ extends T ##

? extends T 描述了通配符上界, 即具体的泛型参数需要满足条件: 泛型参数必须是 T 类型或它的子类, 例如:

List<? extends Number> numberArray = new ArrayList<Number>();  // Number 是 Number 类型的
    List<? extends Number> numberArray = new ArrayList<Integer>(); // Integer 是 Number 的子类
    List<? extends Number> numberArray = new ArrayList<Double>();  // Double 是 Number 的子类

上面三个操作都是合法的, 因为 ? extends Number 规定了泛型通配符的上界, 即我们实际上的泛型必须要是 Number 类型或者是它的子类, 而 Number, Integer, Double 显然都是 Number 的子类(类型相同的也可以, 即这里我们可以认为 Number 是 Number 的子类).

### 子类型判断 ###

假设有类型 G, 以及 SuperClass 和 SubClass 两个类, 并且 SuperClass 是 SubClass 的父类, 那么:

*  G<? extends SubClass> 是 G<? extends SuperClass> 的子类型. 如 List<? extends Integer> 是 List<? extends Number> 的子类型
 *  G 是 G<? extends SuperClass> 的子类型, 例如 List 是 List<? extends Integer> 的子类型.
 *  G<?> 和 G<? extends Object> 等同.

可以想象 G<? extends T> 为一个左闭右开的区间(T 在最左边), G<? extends Object> 是最大的区间, 当区间 G<? extends SuperClass> 包含 区间 G<? extends SubClass>时, 那么较大的区间就是父类.

### 关于读取 ###

根据上面的例子, 对于 List<? extends Number> numberArray 对象:

*  我们能够从 numberArray 中读取到 Number 对象, 因为 numberArray 中包含的元素是 Number 类型或 Number 的子类型.
 *  我们不能从 numberArray 中读取到 Integer 类型, 因为 numberArray 中可能保存的是 Double 类型.
 *  同理, 我们也不能从 numberArray 中读取到 Double 类型.

### 关于写入 ###

根据上面的例子, 对于 List<? extends Number> numberArray 对象:

*  我们不能添加 Number 到 numberArray 中, 因为 numberArray 有可能是List 类型
 *  我们不能添加 Integer 到 numberArray 中, 因为 numberArray 有可能是 List 类型
 *  我们不能添加 Double 到 numberArray 中, 因为 numberArray 有可能是 List 类型

即, 我们不能添加任何对象到 List<? extends T> 中, 因为我们不能确定一个 List<? extends T> 对象实际的类型是什么, 因此就不能确定插入的元素的类型是否和这个 List 匹配. List<? extends T> 唯一能保证的是我们从这个 list 中读取的元素一定是一个 T 类型的.

## ? super T ##

? super T 描述了通配符下界, 即具体的泛型参数需要满足条件: 泛型参数必须是 T 类型或它的父类, 例如:

// 在这里, Integer 可以认为是 Integer 的 "父类"
    List<? super Integer> array = new ArrayList<Integer>();
    // Number 是 Integer 的 父类
    List<? super Integer> array = new ArrayList<Number>();
    // Object 是 Integer 的 父类
    List<? super Integer> array = new ArrayList<Object>();

### 关于读取 ###

对于上面的例子中的 List<? super Integer> array 对象:

*  我们不能保证可以从 array 对象中读取到 Integer 类型的数据, 因为 array 可能是 - List< Number > 类型的.
 *  我们不能保证可以从 array 对象中读取到 Number 类型的数据, 因为 array 可能是 List< Object > 类型的.
 *  唯一能够保证的是, 我们可以从 array 中获取到一个 Object 对象的实例.

### 关于写 ###

对于上面的例子中的 List<? super Integer> array 对象:

*  我们可以添加 Integer 对象到 array 中, 也可以添加 Integer 的子类对象到 array 中.
 *  我们不能添加 Double/Number/Object 等不是 Integer 的子类的对象到 array 中.

## 易混淆点 ##

有一点需要注意的是, List<? super T> 和 List<? extends T> 中, 我们所说的 XX 是 T 的父类(a superclass of T) 或 XX 是 T 的子类(a subclass of T) 其实是针对于泛型参数而言的. 例如考虑如下例子:

List<? super Integer> l1 = ...
    List<? extends Integer> l2 = ...

那么这里 ? super Integer 和 ? extends Integer 的限制是对谁的呢? 是表示我们可以插入任意的对象 X 到 l1 中, 只要 X 是 Integer 的父类? 是表示我们可以插入任意的对象 Y 到 l2 中, 只要 Y 是 Integer 的子类?  
其实不是的, 我们必须要抛弃上面的概念, ? super Integer 和 ? extends Integer 限制的其实是 泛型参数, 即 List<? super Integer> l1 表示 l1 的泛型参数 T 必须要满足 T 是 Integer 的父类, 因此诸如 List< Object >, List< Number >的对象就可以赋值到 l1 中. 正因为我们知道了 l1 中的泛型参数的边界信息, 因此我们就可以向 l1 中添加 Integer 对象了, 推理过程如下:

令 T 是 l1 的泛型参数, 即:
        l1 = List<T> = List<? super Integer>
    因此有 T 是 Integer 或 Integer 的父类.
    如果 T 是 Integer, 则 l1 = List<Integer>, 显然我们可以添加任意的 Integer 对象或 Integer 的子类对象到 l1 中.
    如果 T 是 Integer 的父类, 那么同理, 对于 Integer 或 Integer 的子类的对象, 我们也可以添加到 l1 中.

按同样的分析方式, List<? extends Integer> l2 表示的是 l2 的泛型参数是 Integer 的子类型. 而如果我们要给一个 List 插入一个元素的话, 我们需要保证此元素是 T 或是 T 的子类, 而这里 List<? extends Integer> l2, l2 的泛型参数是什么类型我们都不知道, 进而就不能确定 l2 的泛型参数的子类是哪些, 因此我们就不能向 l2 中添加任何的元素了.  
**来一个对比:**

*  对于 List<? super Integer> l1:
    
     *  正确的理解: ? super Integer 限定的是泛型参数. 令 l1 的泛型参数是 T, 则 T 是 Integer 或 Integer 的父类, 因此 Integer 或 Integer 的子类的对象就可以添加到 l1 中.
     *  错误的理解: ? super Integer限定的是插入的元素的类型, 因此只要是 Integer 或 Integer 的父类的对象都可以插入 l1 中
 *  对于 List<? extends Integer> l2:
    
     *  正确的理解: ? extends Integer 限定的是泛型参数. 令 l2 的泛型参数是 T, 则 T 是 Integer 或 Integer 的子类, 进而我们就不能找到一个类 X, 使得 X 是泛型参数 T 的子类, 因此我们就不可以向 l2 中添加元素. 不过由于我们知道了泛型参数 T 是 Integer 或 Integer 的子类这一点, 因此我们就可以从 l2 中读取到元素(取到的元素类型是 Integer 或 Integer 的子类), 并可以存放到 Integer 中.
     *  错误的理解: ? extends Integer 限定的是插入元素的类型, 因此只要是 Integer 或 Integer 的子类的对象都可以插入 l2 中

## 使用场景 ##

PECS 原则: Producer Extends, Consumer Super

*  Producer extends: 如果我们需要一个 List 提供类型为 T 的数据(即希望从 List 中读取 T 类型的数据), 那么我们需要使用 ? extends T, 例如 List<? extends Integer>. 但是我们不能向这个 List 添加数据.
 *  Consumer Super: 如果我们需要一个 List 来消费 T 类型的数据(即希望将 T 类型的数据写入 List 中), 那么我们需要使用 ? super T, 例如 List<? super Integer>. 但是这个 List 不能保证从它读取的数据的类型.
 *  如果我们既希望读取, 也希望写入, 那么我们就必须明确地声明泛型参数的类型, 例如 List< Integer >.  
    **例子:**

public class Collections {
         
      public static <T> void copy(List<? super T> dest, List<? extends T> src) 
      {
        
          for (int i=0; i<src.size(); i++) 
            dest.set(i,src.get(i)); 
      } 
    }

上面的例子是一个拷贝数据的代码, src 是 List<? extends T> 类型的, 因此它可以读取出 T 类型的数据(读取的数据类型是 T 或是 T 的子类, 但是我们不能确切的知道它是什么类型, 唯一能确定的是读取的类型 is instance of T), , dest 是 List<? super T> 类型的, 因此它可以写入 T 类型或其父类的数据…