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<Number>的對象卻不能由ArrayList<Integer>實例化？list中的<? extends Number>聲明其元素是Number或Number的派生類，爲何不能addInteger和Float?爲了解決這些問題，咱們須要瞭解Java中的逆變和協變以及泛型中通配符用法。

1. 逆變與協變

在介紹逆變與協變以前，先引入Liskov替換原則（Liskov Substitution Principle, LSP）。

Liskov替換原則

LSP由Barbara Liskov於1987年提出，其定義以下：

全部引用基類（父類）的地方必須能透明地使用其子類的對象。

LSP包含如下四層含義：

• 子類徹底擁有父類的方法，且具體子類必須實現父類的抽象方法。
• 子類中能夠增長本身的方法。
• 當子類覆蓋或實現父類的方法時，方法的形參要比父類方法的更爲寬鬆。
• 當子類覆蓋或實現父類的方法時，方法的返回值要比父類更嚴格。

前面的兩層含義比較好理解，後面的兩層含義會在下文中詳細解釋。根據LSP，咱們在實例化對象的時候，能夠用其子類進行實例化，好比：

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<A>，那麼f(⋅) 時逆變、協變仍是不變的呢？若是是逆變，則ArrayList<Integer>是ArrayList<Number>的父類型；若是是協變，則ArrayList<Integer>是ArrayList<Number>的子類型；若是是不變，兩者沒有相互繼承關係。開篇代碼中用ArrayList<Integer>實例化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中泛型是不變的，可有時須要實現逆變與協變，怎麼辦呢？這時，通配符?派上了用場：

• <? extends>實現了泛型的協變，好比：

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

• <? super>實現了泛型的逆變，好比：

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

extends與super

爲何（開篇代碼中）List<? extends Number> list在addInteger和Float會發生編譯錯誤？首先，咱們看看add的實現：

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

在調用add方法時，泛型E自動變成了<? extends Number>，其表示list所持有的類型爲在Number與Number派生子類中的某一類型，其中包含Integer類型卻又不特指爲Integer類型（Integer像個備胎同樣！！！），故addInteger時發生編譯錯誤。

爲了能調用add方法，能夠用super關鍵字實現：

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

<? super Number>表示list所持有的類型爲在Number與Number的基類中的某一類型，其中Integer與Float一定爲這某一類型的子類；因此add方法能被正確調用。從上面的例子能夠看出，extends肯定了泛型的上界，而super肯定了泛型的下界。

PECS

如今問題來了：究竟何時用extends何時用super呢？《Effective Java》給出了答案：

PECS: producer-extends, consumer-super.

好比，一個簡單的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>的子類型。於是，應改成：

// 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都不用）。