本文内容纲要：

-1.逆变与协变 -Liskov替换原则 -定义 -类型转换 -2.泛型中的通配符 -实现泛型的协变与逆变 -extends与super -PECS -3.参考资料

看下面一段代码

Numbernum=newInteger(1); ArrayList<Number>list=newArrayList<Integer>();//typemismatch List<?extendsNumber>list=newArrayList<Number>(); list.add(newInteger(1));//error list.add(newFloat(1.2f));//error

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

1.逆变与协变

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

Liskov替换原则

LSP由BarbaraLiskov于1987年提出，其定义如下：

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

LSP包含以下四层含义：

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

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

Numbernum=newInteger(1);

定义

逆变与协变用来描述类型转换（typetransformation）后的继承关系，其定义：如果\(A\)、\(B\)表示类型，\(f(\cdot)\)表示类型转换，\(\leq\)表示继承关系（比如，\(A\leqB\)表示\(A\)是由\(B\)派生出来的子类）；

\(f(\cdot)\)是逆变（contravariant）的，当\(A\leqB\)时有\(f(B)\leqf(A)\)成立； \(f(\cdot)\)是协变（covariant）的，当\(A\leqB\)时有\(f(A)\leqf(B)成立\)； \(f(\cdot)\)是不变（invariant）的，当\(A\leqB\)时上述两个式子均不成立，即\(f(A)\)与\(f(B)\)相互之间没有继承关系。

类型转换

接下来，我们看看Java中的常见类型转换的协变性、逆变性或不变性。

泛型

令f(A)=ArrayList<A>，那么\(f(\cdot)\)时逆变、协变还是不变的呢？如果是逆变，则ArrayList<Integer>是ArrayList<Number>的父类型；如果是协变，则ArrayList<Integer>是ArrayList<Number>的子类型；如果是不变，二者没有相互继承关系。开篇代码中用ArrayList<Integer>实例化list的对象错误，则说明泛型是不变的。

数组

令f(A)=[]A，容易证明数组是协变的：

Number[]numbers=newInteger[3];

方法

方法的形参是协变的、返回值是逆变的：

通过与网友iamzhoug37的讨论，更新如下。

调用方法result=method(n)；根据Liskov替换原则，传入形参n的类型应为method形参的子类型，即typeof(n)≤typeof(methodsparameter)；result应为method返回值的基类型，即typeof(methodssreturn)≤typeof(result)：

staticNumbermethod(Numbernum){ return1; } Objectresult=method(newInteger(2));//correct Numberresult=method(newObject());//error Integerresult=method(newInteger(2));//error

在Java1.4中，子类覆盖（override）父类方法时，形参与返回值的类型必须与父类保持一致：

classSuper{ Numbermethod(Numbern){...} } classSubextendsSuper{ @Override Numbermethod(Numbern){...} }

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

classSuper{ Numbermethod(Numbern){...} } classSubextendsSuper{ @Override Integermethod(Numbern){...} }

2.泛型中的通配符

实现泛型的协变与逆变

Java中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时，通配符?派上了用场：

<?extends>实现了泛型的协变，比如：

List<?extendsNumber>list=newArrayList();

<?super>实现了泛型的逆变，比如：

List<?superNumber>list=newArrayList();

extends与super

为什么（开篇代码中）List<?extendsNumber>list在addInteger和Float会发生编译错误？首先，我们看看add的实现：

publicinterfaceList<E>extendsCollection<E>{ booleanadd(Ee); }

在调用add方法时，泛型E自动变成了<?extendsNumber>，其表示list所持有的类型为在Number与Number派生子类中的某一类型，其中包含Integer类型却又不特指为Integer类型（Integer像个备胎一样！！！），故addInteger时发生编译错误。为了能调用add方法，可以用super关键字实现：

List<?superNumber>list=newArrayList<Object>(); list.add(newInteger(1)); list.add(newFloat(1.2f));

<?superNumber>表示list所持有的类型为在Number与Number的基类中的某一类型，其中Integer与Float必定为这某一类型的子类；所以add方法能被正确调用。从上面的例子可以看出，extends确定了泛型的上界，而super确定了泛型的下界。

PECS

现在问题来了：究竟什么时候用extends什么时候用super呢？《EffectiveJava》给出了答案：

PECS:producer-extends,consumer-super.

比如，一个简单的StackAPI：

publicclassStack<E>{ publicStack(); publicvoidpush(Ee): publicEpop(); publicbooleanisEmpty(); }

要实现pushAll(Iterable<E>src)方法，将src的元素逐一入栈：

publicvoidpushAll(Iterable<E>src){ for(Ee:src) push(e) }

假设有一个实例化Stack<Number>的对象stack，src有Iterable<Integer>与Iterable<Float>；在调用pushAll方法时会发生typemismatch错误，因为Java中泛型是不可变的，Iterable<Integer>与Iterable<Float>都不是Iterable<Number>的子类型。因此，应改为

//WildcardtypeforparameterthatservesasanEproducer publicvoidpushAll(Iterable<?extendsE>src){ for(Ee:src) push(e); }

要实现popAll(Collection<E>dst)方法，将Stack中的元素依次取出add到dst中，如果不用通配符实现：

//popAllmethodwithoutwildcardtype-deficient! publicvoidpopAll(Collection<E>dst){ while(!isEmpty()) dst.add(pop()); }

同样地，假设有一个实例化Stack<Number>的对象stack，dst为Collection<Object>；调用popAll方法是会发生typemismatch错误，因为Collection<Object>不是Collection<Number>的子类型。因而，应改为：

//WildcardtypeforparameterthatservesasanEconsumer publicvoidpopAll(Collection<?superE>dst){ while(!isEmpty()) dst.add(pop()); }

在上述例子中，在调用pushAll方法时生产了E实例（producesEinstances），在调用popAll方法时dst消费了E实例（consumesEinstances）。Naftalin与Wadler将PECS称为GetandPutPrinciple。

java.util.Collections的copy方法(JDK1.7)完美地诠释了PECS：

publicstatic<T>voidcopy(List<?superT>dest,List<?extendsT>src){ intsrcSize=src.size(); if(srcSize>dest.size()) thrownewIndexOutOfBoundsException("Sourcedoesnotfitindest"); if(srcSize<COPY_THRESHOLD|| (srcinstanceofRandomAccess&&destinstanceofRandomAccess)){ for(inti=0;i<srcSize;i++) dest.set(i,src.get(i)); }else{ ListIterator<?superT>di=dest.listIterator(); ListIterator<?extendsT>si=src.listIterator(); for(inti=0;i<srcSize;i++){ di.next(); di.set(si.next()); } } }

PECS总结：

要从泛型类取数据时，用extends； 要往泛型类写数据时，用super； 既要取又要写，就不用通配符（即extends与super都不用）。

3.参考资料

[1]meriton,Covariance,InvarianceandContravarianceexplainedinplainEnglish?.

[2]BertF,Differencebetween and inJava.

[3]JoshuaBloch,EffectiveJava.

本文内容总结：1.逆变与协变，Liskov替换原则，定义，类型转换，2.泛型中的通配符，实现泛型的协变与逆变，extends与super，PECS，3.参考资料，

原文链接：https://www.cnblogs.com/en-heng/p/5041124.html