Java中的逆變與協變

導讀	有人會納悶，為什麼Number的物件可以由Integer例項化，而ArrayList的物件卻不能由ArrayList例項化？list中的宣告其元素是Number或Number的派生類，為什麼不能add Integer和Float?為了解決這些問題，我們需要了解Java中的逆變和協變以及泛型中萬用字元用法。

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

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，那麼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) { ... }
}

Java中泛型是不變的，可有時需要實現逆變與協變，怎麼辦呢？這時，萬用字元?派上了用場：

實現了泛型的協變，比如：

List list = new ArrayList();

實現了泛型的逆變，比如：

List list = new ArrayList();

為什麼（開篇程式碼中）List list在add Integer和Float會發生編譯錯誤？首先，我們看看add的實現：

public interface Listextends Collection{
    boolean add(E e);
}

在呼叫add方法時，泛型E自動變成了，其表示list所持有的型別為在Number與Number派生子類中的某一型別，其中包含Integer型別卻又不特指為Integer型別（Integer像個備胎一樣！！！），故add Integer時發生編譯錯誤。為了能呼叫add方法，可以用super關鍵字實現：

List list = new ArrayList();
list.add(new Integer(1));
list.add(new Float(1.2f));

表示list所持有的型別為在Number與Number的基類中的某一型別，其中Integer與Float必定為這某一型別的子類；所以add方法能被正確呼叫。從上面的例子可以看出，extends確定了泛型的上界，而super確定了泛型的下界。

現在問題來了：究竟什麼時候用extends什麼時候用super呢？《Effective Java》給出了答案：

PECS: producer-extends, consumer-super.
比如，一個簡單的Stack API：

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

要實現pushAll(Iterable src)方法，將src的元素逐一入棧：

public void pushAll(Iterablesrc){
    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 src) {
    for (E e : src)
        push(e);
}

要實現popAll(Collection dst)方法，將Stack中的元素依次取出add到dst中，如果不用萬用字元實現：

// popAll method without wildcard type - deficient!
public void popAll(Collectiondst) {
    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 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 staticvoid copy(List dest, List 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<1srcsize; i++)="" dest.set(i,="" src.get(i));="" }="" else="" {="" listiteratordi=dest.listIterator();
        ListIterator si=src.listIterator();
        for (int i=0; i<1srcsize; i++)="" {="" di.next();="" di.set(si.next());="" }=""

PECS總結：

要從泛型類取資料時，用extends；

要往泛型類寫資料時，用super；

既要取又要寫，就不用萬用字元（即extends與super都不用）。

原文來自：