泛型的协变与逆变
看下面一段代码：
Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatchList<? extends Number> list = new ArrayList<Number>(); list.add(new Integer(1)); //error list.add(new Float(1.2f)); //errorInteger是Number的子类，Integer类型的实例可以赋值给Number类型的变量，为什么ArrayList<Integer>不可以赋值给ArrayList<Number>?这需要我们了解Java中的泛型通配符以及协变与逆变。
协变与逆变
Liskov替换原则
所有引用基类（父类）的地方必须能透明地使用其子类的对象。
LSP包含以下四层含义：
- 子类完全拥有父类的方法，且具体子类必须实现父类的抽象方法。
- 子类中可以增加自己的方法。
- 当子类覆盖或实现父类的方法时，方法的形参要比父类方法的更为宽松。
- 当子类覆盖或实现父类的方法时，方法的返回值要比父类更严格。
定义
逆变与协变用来描述类型转换（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)相互之间没有继承关系。
类型协变性
数组是协变的
// CovariantArrays.java class Fruit {} class Apple extends Fruit {} class Jonathan extends Apple {} class Orange extends Fruit {}public class CovariantArrays {public static void main(String[] args) {Fruit[] fruit = new Apple[10];fruit[0] = new Apple();fruit[1] = new Jonathan();try {fruit[0] = new Fruit();} catch (Exception e) {System.out.println(e);}try {fruit[0] = new Orange();} catch (Exception e) {System.out.println(e);}} }fruit数组在编译期间是可以编译的。但是在运行期间会出异常。因为fruit[0]是Apple类型的，在赋值为Orange类型时出异常。
泛型是不变的
方法
调用方法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中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时，通配符?派上了用场：
<? 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.
如果类型形参表示一个T生产者，就使用<? extends T>，如果表示一个消费者，就使用<? super T>。
比如，一个简单的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都不用）。
自限定的类型
理解自限定
Java泛型中，有一个好像是经常性出现的惯用法，它相当令人费解。
class SelfBounded<T extends SelfBounded<T>> { // ...SelfBounded类接受泛型参数T，而T由一个边界类限定，这个边界就是拥有T作为其参数的SelfBounded，看起来是一种无限循环。
先给出结论：这种语法定义了一个基类，这个基类能够使用子类作为其参数、返回类型、作用域。为了理解这个含义，我们从一个简单的版本入手。
// BasicHolder.java public class BasicHolder<T> {T element;void set(T arg) { element = arg; }T get() { return element; }void f() {System.out.println(element.getClass().getSimpleName());} }// CRGWithBasicHolder.java class Subtype extends BasicHolder<Subtype> {}public class CRGWithBasicHolder {public static void main(String[] args) {Subtype st1 = new Subtype(), st2 = new Subtype();st1.set(st2);Subtype st3 = st1.get();st1.f();} } /* 程序输出 Subtype */新类Subtype接受的参数和返回的值具有Subtype类型而不仅仅是基类BasicHolder类型。所以自限定类型的本质就是：基类用子类代替其参数。这意味着泛型基类变成了一种其所有子类的公共功能模版，但是在所产生的类中将使用确切类型而不是基类型。因此，Subtype中，传递给set()的参数和从get() 返回的类型都确切是Subtype。
自限定与协变
自限定类型的价值在于它们可以产生协变参数类型——方法参数类型会随子类而变化。其实自限定还可以产生协变返回类型，但是这并不重要，因为JDK1.5引入了协变返回类型。
协变返回类型
下面这段代码子类接口把基类接口的方法重写了，返回更确切的类型。
// CovariantReturnTypes.java class Base {} class Derived extends Base {}interface OrdinaryGetter { Base get(); }interface DerivedGetter extends OrdinaryGetter {Derived get(); }public class CovariantReturnTypes {void test(DerivedGetter d) {Derived d2 = d.get();} }继承自定义类型基类的子类将产生确切的子类型作为其返回值，就像上面的get()一样。
// GenericsAndReturnTypes.java interface GenericsGetter<T extends GenericsGetter<T>> {T get(); }interface Getter extends GenericsGetter<Getter> {}public class GenericsAndReturnTypes {void test(Getter g) {Getter result = g.get();GenericsGetter genericsGetter = g.get();} }协变参数类型
在非泛型代码中，参数类型不能随子类型发生变化。方法只能重载不能重写。见下面代码示例。
// OrdinaryArguments.java class OrdinarySetter {void set(Base base) {System.out.println("OrdinarySetter.set(Base)");} }class DerivedSetter extends OrdinarySetter {void set(Derived derived) {System.out.println("DerivedSetter.set(Derived)");} }public class OrdinaryArguments {public static void main(String[] args) {Base base = new Base();Derived derived = new Derived();DerivedSetter ds = new DerivedSetter();ds.set(derived);ds.set(base);} } /* 程序输出 DerivedSetter.set(Derived) OrdinarySetter.set(Base) */但是，在使用自限定类型时，在子类中只有一个方法，并且这个方法接受子类型而不是基类型为参数。
interface SelfBoundSetter<T extends SelfBoundSetter<T>> {void set(T args); }interface Setter extends SelfBoundSetter<Setter> {}public class SelfBoundAndCovariantArguments {void testA(Setter s1, Setter s2, SelfBoundSetter sbs) {s1.set(s2);s1.set(sbs); // 编译错误} }捕获转换
<?>被称为无界通配符，无界通配符有什么作用这里不再详细说明了，理解了前面东西的同学应该能推断出来。无界通配符还有一个特殊的作用，如果向一个使用<?>的方法传递原生类型，那么对编译期来说，可能会推断出实际的参数类型，使得这个方法可以回转并调用另一个使用这个确切类型的方法。这种技术被称为捕获转换。下面代码演示了这种技术。
public class CaptureConversion {static <T> void f1(Holder<T> holder) {T t = holder.get();System.out.println(t.getClass().getSimpleName());}static void f2(Holder<?> holder) {f1(holder);}@SuppressWarnings("unchecked")public static void main(String[] args) {Holder raw = new Holder<Integer>(1);f2(raw);Holder rawBasic = new Holder();rawBasic.set(new Object());f2(rawBasic);Holder<?> wildcarded = new Holder<Double>(1.0);f2(wildcarded);} } /* 程序输出 Integer Object Double */捕获转换只有在这样的情况下可以工作：即在方法内部，你需要使用确切的类型。注意，不能从f2()中返回T，因为T对于f2()来说是未知的。捕获转换十分有趣，但是非常受限。
总结
- 上一篇： 反射-Class
- 下一篇： hamcrest详细介绍