Java中逆变与协变

看下面一段代码

Number num = new Integer(1);  
ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch

List<? extends Number> list = new ArrayList<Number>();
list.add(new Integer(1)); //error
list.add(new Float(1.2f));  //error

有人会纳闷，为什么Number的对象可以由Integer实例化，而ArrayList的对象却不能由ArrayList实例化？list中的

Number num = new Integer(1);

定义

逆变与协变用来描述类型转换（type transformation）后的继承关系，其定义：如果A 、B 表示类型，f(⋅) 表示类型转换，≤ 表示继承关系（比如，A≤B 表示A 是由B 派生出来的子类）；

f(⋅) 是逆变（contravariant）的，当A≤B 时有f(B)≤f(A) 成立；
f(⋅) 是协变（covariant）的，当A≤B 时有f(A)≤f(B)成立 ；
f(⋅) 是不变（invariant）的，当A≤B 时上述两个式子均不成立，即f(A) 与f(B) 相互之间没有继承关系。
类型转换

接下来，我们看看Java中的常见类型转换的协变性、逆变性或不变性。

泛型

令f(A)=ArrayList，那么f(⋅) 时逆变、协变还是不变的呢？如果是逆变，则ArrayList是ArrayList的父类型；如果是协变，则ArrayList是ArrayList的子类型；如果是不变，二者没有相互继承关系。开篇代码中用ArrayList实例化list的对象错误，则说明泛型是不变的。

数组

令f(A)=[]A，容易证明数组是协变的：

Number[] numbers = new Integer[3];

方法

调用方法result = method(n)；根据Liskov替换原则，传入形参n的类型应为method形参的子类型，即typeof(n)≤typeof(method’s parameter)；result应为method返回值的基类型，即typeof(methods’s return)≤typeof(result)：

static Number method(Number num) {
    return 1;
}

Object result = method(new Integer(2)); //correct
Number result = method(new Object()); //error
Integer result = method(new Integer(2)); //error

在Java 1.4中，子类覆盖（override）父类方法时，形参与返回值的类型必须与父类保持一致：

class Super {
    Number method(Number n) { ... }
}

class Sub extends Super {
    @Override 
    Number method(Number n) { ... }
}

从Java 1.5开始，子类覆盖父类方法时允许协变返回更为具体的类型：

class Super {
    Number method(Number n) { ... }
}

class Sub extends Super {
    @Override 
    Integer method(Number n) { ... }
}

2. 泛型中的通配符

实现泛型的协变与逆变

Java中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时，通配符?派上了用场：

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

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

extends与super

为什么（开篇代码中）List

public interface List<E> extends Collection<E> {
    boolean add(E e);
}

在调用add方法时，泛型E自动变成了

List<? super Number> list = new ArrayList<Object>();
list.add(new Integer(1));
list.add(new Float(1.2f));

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

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

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

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

// 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 dst)方法，将Stack中的元素依次取出add到dst中，如果不用通配符实现：

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

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

// Wildcard type for parameter that serves as an E consumer
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());
        }
    }
}

PECS总结：

要从泛型类取数据时，用extends；
要往泛型类写数据时，用super；
既要取又要写，就不用通配符（即extends与super都不用）。