歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

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的派生類,為什麼不能add IntegerFloat?為了解決這些問題,我們需要了解Java中的逆變和協變以及泛型中通配符用法。

1. 逆變與協變

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

Liskov替換原則

LSP由Barbara Liskov於1987年提出,其定義如下:

所有引用基類(父類)的地方必須能透明地使用其子類的對象。

LSP包含以下四層含義:

  • 子類完全擁有父類的方法,且具體子類必須實現父類的抽象方法。
  • 子類中可以增加自己的方法。
  • 當子類覆蓋或實現父類的方法時,方法的形參要比父類方法的更為寬松。
  • 當子類覆蓋或實現父類的方法時,方法的返回值要比父類更嚴格。

前面的兩層含義比較好理解,後面的兩層含義會在下文中詳細解釋。根據LSP,我們在實例化對象的時候,可以用其子類進行實例化,比如:

Number num = new Integer(1); 

定義

逆變與協變用來描述類型轉換(type transformation)後的繼承關系,其定義:如果AB表示類型,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]; 

方法

方法的形參是協變的、返回值是逆變的:


通過與網友iamzhoug37的討論,更新如下。

調用方法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在add IntegerFloat會發生編譯錯誤?首先,我們看看add的實現:

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

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

為了能調用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();
    publicvoidpush(E e):
    public E pop();
    publicbooleanisEmpty();
}

要實現pushAll(Iterable<E> src)方法,將src的元素逐一入棧:

publicvoidpushAll(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
publicvoidpushAll(Iterable<? extends E> src) {
    for (E e : src)
        push(e);
}

要實現popAll(Collection<E> dst)方法,將Stack中的元素依次取出add到dst中,如果不用通配符實現:

// popAll method without wildcard type - deficient!
publicvoidpopAll(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
publicvoidpopAll(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> voidcopy(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都不用)。

3. 參考資料

[1] meriton, Covariance, Invariance and Contravariance explained in plain English?.
[2] Bert F, Difference between <? super T> and <? extends T> in Java.
[3] Joshua Bloch, Effective Java.

Copyright © Linux教程網 All Rights Reserved