逆变、协变

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)); //errorlist.add(new Float(1.2f));  //error

List<? extends Number> list = new ArrayList<Integer>();list.add(new Integer(1)); // type mismatch

上面这段代码，有人会纳闷，为什么Number的对象可以由Integer实例化（因为向上转型啊），而ArrayList< Number >的对象却不能由ArrayList< Integer >实例化？list中的< ? extends Number>声明其元素是Number或Number的派生类，为什么不能add Integer和Float？为了解决这些问题，我们需要了解Java中的逆变和协变以及泛型中通配符用法。

---

在介绍逆变与协变之前，先引入Liskov替换原则（Liskov Substitution Principle, LSP）。

Liskov替换原则：

所有引用基类（父类）的地方必须能透明地使用其子类的对象。

LSP包含以下四层含义：

• 子类完全拥有父类的方法，且具体子类必须实现父类的抽象方法。
• 子类中可以增加自己的方法。
• 当子类覆盖或实现父类的方法时，方法的形参要比父类方法的更为宽松。
• 当子类覆盖或实现父类的方法时，方法的返回值要比父类更严格。

前面的两层含义比较好理解，后面的两层含义会在下文中详细解释。根据LSP，我们在实例化对象的时候，可以用其子类进行实例化，比如：

Number num = new Integer(1);

---

1.逆变与协变

逆变与协变用来描述类型转换（type transformation）后的继承关系。

Java中String类型是继承自Object的，姑且记做String ≦ Object，表示String是Object的子类型，String的对象可以赋给Object的对象。而Object的数组类型Object[]，理解成是由Object构造出来的一种新的类型,可以认为是一种构造类型，记f(Object)，那么可以这么来描述协变和逆变：

   当A ≦ B时,如果有f(A) ≦ f(B),那么f叫做协变；   当A ≦ B时,如果有f(B) ≦ f(A),那么f叫做逆变；   如果上面两种关系都不成立则叫做不可变。

---

2.类型转换

接下来，我们看看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];

方法
1.调用方法时

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

在Java 1.4中，子类覆盖（override）父类方法时，形参与返回值的类型必须与父类型相同

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

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

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

---

3.泛型中的通配符

实现泛型的协变与逆变

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类型，故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的基类（父类，但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 producerpublic 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 consumerpublic 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());            }        }    }

（？）
要从泛型类取数据时，用extends；（如前例从src中取数据入栈）
要往泛型类写数据时，用super；（如前例往dst里存放数据）
既要取又要写，就不用通配符（即extends与super都不用）。

---

个人总结：
协变和逆变中，基本思想还是与java中的向上转型紧密相关（一些type mismatch的原因都能用此解释）。而关于通配符的使用给出的意见，是在简化操作的基础上提出的，如果本身不追求这种操作并没有必要使用。