看下面一段代碼
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 Integer和Float?為了解決這些問題，我們需要了解Java中的逆變和協變以及泛型中通配符用法。
1. 逆變與協變
在介紹逆變與協變之前，先引入Liskov替換原則（Liskov Substitution Principle, LSP）。
Liskov替換原則
LSP由Barbara Liskov於1987年提出，其定義如下：
所有引用基類（父類）的地方必須能透明地使用其子類的對象。
LSP包含以下四層含義：
- 子類完全擁有父類的方法，且具體子類必須實現父類的抽象方法。
- 子類中可以增加自己的方法。
- 當子類覆蓋或實現父類的方法時，方法的形參要比父類方法的更為寬松。
- 當子類覆蓋或實現父類的方法時，方法的返回值要比父類更嚴格。
前面的兩層含義比較好理解，后面的兩層含義會在下文中詳細解釋。根據LSP，我們在實例化對象的時候，可以用其子類進行實例化，比如：
Number num = new Integer(1); 定義
逆變與協變用來描述類型轉換（type transformation）后的繼承關系，其定義：如果AA、BB表示類型，f(⋅)f(⋅)表示類型轉換，≤≤表示繼承關系（比如，A≤BA≤B表示AA是由BB派生出來的子類）；
- f(⋅)f(⋅)是逆變（contravariant）的，當A≤BA≤B時有f(B)≤f(A)f(B)≤f(A)成立；
- f(⋅)f(⋅)是協變（covariant）的，當A≤BA≤B時有f(A)≤f(B)成立f(A)≤f(B)成立；
- f(⋅)f(⋅)是不變（invariant）的，當A≤BA≤B時上述兩個式子均不成立，即f(A)f(A)與f(B)f(B)相互之間沒有繼承關系。
類型轉換
接下來，我們看看Java中的常見類型轉換的協變性、逆變性或不變性。
泛型
令f(A)=ArrayList<A>，那么f(⋅)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 Integer和Float會發生編譯錯誤？首先，我們看看add的實現：
public interface List<E> extends Collection<E> { boolean add(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(); 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都不用）。
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.