看下面一段代码：

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

Integer是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()来说是未知的。捕获转换十分有趣，但是非常受限。

泛型的协变与逆变协变与逆变自限定的类型捕获转换

协变与逆变

Liskov替换原则

定义

类型协变性

数组是协变的

泛型是不变的

方法

通配符引入协变、逆变

extends与super

PECS

PECS总结：

自限定的类型

理解自限定

自限定与协变

捕获转换

继续阅读

5 个有用的 TypeScript 技巧

2015.7.26阅读笔记

卷妹带你回顾Java基础(一)每日更新Day3

Java常见面试问题

C++泛型与多态（4）：Duck Typing

Java泛型通配符extends与super

Java范型中 ? extends T 和 ? super T 的区别extendsSuperPECSextendssuper

java 泛型中的T、?、＜? extends T＞、＜? super T＞

泛型限定符------extend和super

Java泛型中extends和super的理解Java泛型中K T V E ？ object等的含义

spring(学习记录）泛型依赖注入

Quartz.NET 2.0与以前版本的改进

JAVA 泛型程序设计 -- 《JAVA 核心技术卷I》

为什么 Java 不支持泛型数组

Java泛型详解第一次接触泛型完成泛型泛型擦除