Java泛型的拓展

Posted on 2017-06-27 Edited on 2026-07-03 In 编程语言

Java泛型拓展

基础知识之协变与逆变

// public final class Integer extends Number  
Number num = new Integer(1);    
List<Number> list = new ArrayList<>();  
list.add(new Integer(3));  
ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch 这两个根本就不是一个类型 
  
List<? extends Number> list = new ArrayList<Number>();  
list.add(new Integer(1)); //error

为什么Number的对象可以由Integer实例化，而ArrayList<Number>的对象却不能由ArrayList<Integer>实例化？List中的<? extends Number>声明其元素是Number或Number的派生类，为什么不能add Integer?为了解决这些问题，需要了解Java中的逆变和协变以及泛型中通配符用法。

Java中String类型是继承自Object的，姑且记做String ≦ Object，表示String是Object的子类型，String的对象可以赋给Object的对象。而Object的数组类型Object[]，理解成是由Object构造出来的一种新的类型,可以认为是一种构造类型，记f(Object)，那么可以这么来描述协变和逆变：

当A ≦ B时,如果有f(A) ≦ f(B),那么f叫做协变；

当A ≦ B时,如果有f(B) ≦ f(A),那么f叫做逆变；

如果上面两种关系都不成立则叫做不可变。

JAVA中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时就需要通配符?。

协变

<? extends Number>实现了Java中的协变

1	List<? extends Number> list = new ArrayList<>(); ·

<? extends Number>表示通配符?的上界为Number，即“? extends Number”可以代表Number或其子类，但代表不了Number的父类（如Object），因为通配符的上界是Number。

于是有? extends Number ≦ Number，则List<? extends Number> ≦ List< Number >。那么就有：

1 2	List<? extends Number> list001 = new ArrayList<Integer>(); List<? extends Number> list002 = new ArrayList<Float>();

但是这里不能向list001、list002添加除null以外的任意对象。可以这样理解一下，List<Integer>可以添加Interger及其子类，List<Float>可以添加Float及其子类，List<Integer>、List<Float>都是List<? extends Animal>的子类型，如果能将Float的子类添加到List<? extends Animal>中，就说明Float的子类也是可以添加到List<Integer>中的，显然是不可行。故java为了保护其类型一致，禁止向List<? extends Number>添加任意对象，不过却可以添加null。

逆变

<? super>实现了泛型的逆变，比如：

1	List<? super Number> list = new ArrayList<>();

? super Number 则表示通配符?的下界为Number。为了保护类型的一致性，因为？ super Number可以是Object或其他Number的父类，因无法确定其类型，也就不能往List<? super Number >添加Number的任意父类对象。但是可以向List<? super Number>添加Number及其子类。

List<? super Number> list001 = new ArrayList<Number>();  
List<? super Number> list002 = new ArrayList<Object>();  
list001.add(new Integer(3));  
list002.add(new Integer(3));

PECS

现在问题来了：究竟什么时候用extends什么时候用super呢？《Effective Java》给出了答案：

PECS: producer-extends, consumer-super.

PECS指“Producer Extends，Consumer Super”。换句话说，如果参数化类型表示一个生产者，就使用<? extends T>；如果它表示一个消费者，就使用<? super T>。

比如一个Stack API

public class Stack<E>{  
    public Stack();  
    public void push(E e):  
    public E pop();  
    public boolean isEmpty();  
}

要实现pushAll(Iterable<E> src)方法，将src的元素逐一入栈：

public void pushAll(Iterable<E> src){  
    for(E e : src)  
        push(e)  
}

假设有一个实例化Stack<Number>的对象stack，src有Iterable<Integer>与 Iterable<Float>；在调用pushAll方法时会发生type mismatch错误，因为Java中泛型是不可变的，Iterable<Integer>与 Iterable<Float>都不是Iterable<Number>的子类型。因此，应改为

// Wildcard type for parameter that serves as an E producer  
public void pushAll(Iterable<? extends E> src){
  for(E e : src)  
        push(e)
}

要实现popAll(Collection<E> dst)方法，将Stack中的元素依次取出add到dst中，如果不用通配符实现:

// popAll method without wildcard type - deficient!  
public void popAll(Collection<E> dst) {  
    while (!isEmpty())  
        dst.add(pop());     
}

同样地，假设有一个实例化Stack<Number>的对象stack，dst为Collection<Object>；调用popAll方法是会发生type mismatch错误，因为Collection<Object>不是Collection<Number>的子类型。因而，应改为：

public void popAll(Collection<? super E> dst){
  while(!isEmpty()){
    dst.add(pop);
  }
}

在上述例子中，在调用pushAll方法时生产了E 实例（produces E instances），在调用popAll方法时dst消费了E 实例（consumes E instances）。Naftalin与Wadler将PECS称为Get and Put Principle。

java.util.Collections的copy方法(JDK1.7)完美地诠释了PECS：

public static <T> void copy(List<? super T> dest, List<? extends T> src) {  
    int srcSize = src.size();  
    if (srcSize > dest.size())  
        throw new IndexOutOfBoundsException("Source does not fit in dest");  
  
    if (srcSize < COPY_THRESHOLD ||  
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {  
        for (int i=0; i<srcSize; i++)  
            dest.set(i, src.get(i));  
    } else {  
        ListIterator<? super T> di=dest.listIterator();  
        ListIterator<? extends T> si=src.listIterator();  
        for (int i=0; i<srcSize; i++) {  
            di.next();  
            di.set(si.next());  
        }  
    }  
}

通配符的副作用

//以盘子为例
class plate<T>{
  private T item;
  public Plate(T t){
    item = t;
  }
  public void set(T t){
    item = t;
  }
  public void get(){
    return item;
  }
}

class Fruit{}
class Apple extends Apple{}
//上界<? enteds T>只能取，不能存。
//code block
Plate<? extends Fruit> p = new plate<Apple>(new Apple());

//不能存储任何元素；
p.set(new Fruit());
p.set(new Apple());


//读取出来的东西只能放在Fruit或者是它的基类里。
Fruit f = p.get();
Object f1 = p.get();
Apple af = p.get() // ERROR;

//其实锅都在编译器中：

原因是编译器只知道容器内是Fruit或者它的派生类，但具体是什么类型不知道。可能是Fruit？可能是Apple？也可能是Banana，RedApple，GreenApple？编译器在看到后面用Plate赋值以后，盘子里没有被标上有“苹果”。而是标上一个占位符：CAP#1，来表示捕获一个Fruit或Fruit的子类，具体是什么类不知道，代号CAP#1。然后无论是想往里插入Apple或者Meat或者Fruit编译器都不知道能不能和这个CAP#1匹配，所以就都不允许。

所以通配符<?>和类型参数的区别就在于，对编译器来说所有的T都代表同一种类型。比如下面这个泛型方法里，三个T都指代同一个类型，要么都是String，要么都是Integer。

1	public <T> List<T> fill(T... t);

但通配符<?>没有这种约束，Plate<?>单纯的就表示：盘子里放了一个东西，是什么我不知道。

所以题主问题里的错误就在这里，Plate<？ extends Fruit>里什么都放不进去。

下界<? super T>不影响往里存，但往外取只能放在Object对象里

使用下界<? super Fruit>会使从盘子里取东西的get( )方法部分失效，只能存放到Object对象里。set( )方法正常.

p=new Plate(new Fruit());

//存入元素正常
p.set(new Fruit());
p.set(new Apple());

//读取出来的东西只![KjDLw](../../../Desktop/KjDLw.png)能存放在Object类里。
Apple newFruit3=p.get();    //Error
Fruit newFruit1=p.get();    //Error
Object newFruit2=p.get();

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Fruit的基类，那往里存粒度比Fruit小的都可以。但往外读取元素就费劲了，只有所有类的基类Object对象才能装下。但这样的话，元素的类型信息就全部丢失。

总结 PECS原则：

最后看一下什么是PECS（Producer Extends Consumer Super）原则，已经很好理解了：

频繁往外读取内容的，适合用上界Extends。
经常往里插入的，适合用下界Super。

The principles behind this in Computer Science is named after

Covariance - ? extends MyClass,
Contravariance - ? super MyClass and
Invariance/non-Variance - MyClass

The picture below should explain the concept.

KjDLw

（图片来源 https://stackoverflow.com/users/2707792/andrey-tyukin）

TODO :好好理解一下PECS 原则？到底什么时候是生产，什么时候是消费。生产了什么与消费了什么？

参考内容：

[1] http://www.cnblogs.com/drizzlewithwind/p/6100164.html；