泛型逆变

逆变

除了使用extends通配符外，还可以使用超类型通配符。这里，可以声明通配符是由某个特定类的任何基类来界定的，方法是指定<? super MyClass>，甚至或者使用类型参数：<? super T>（尽管不能对泛型参数给出一个超类型边界）；即不能声明<T super MyClass>。这使得可以安全地传递一个类型对象到泛型参数中。因此，有了超类型通配符，就看向Collection写入了。

public class SuperTypeWildcards {
    static void writeTo(List<? super Apple> apples) {
        apples.add(new Apple());
        apples.add(new Jonathan());
        // apples.add(new Fruit()); Error
    }
}

参数apples是Apple的某种基类型的List，所以向里面添加Apple或者Apple的子类型是安全的。但是既然Apple是下界，那么向这样的List添加Fruits是不安全的。因为这会使List敞开口子，从而可以向里面添加非Apple类型的对象，而这样是违反静态类型安全的。
因此代码中可能会根据如何能够向一个泛型类型“写入”(传递给一个方法)，以及如何能够从一个泛型类型中“读取”(从一个方法中返回)，来着手思考子类型和超类型边界。
超类型边界放松了在可以向方法传递的参数上的限制。

public class GenericWriting {
    static <T> void writeExact(List<T> list, T item) {
        list.add(item);
    }

    static List<Apple> apples = new ArrayList<>();
    static List<Fruit> fruits = new ArrayList<>();

    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruits, new Apple());
    }

    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item);
    }

    static void f2(){
        writeWithWildcard(apples,new Apple());
        writeWithWildcard(fruits,new Apple());
    }

    public static void main(String[] args) {
        f1();
        f2();
    }
}

上面的代码中，f1()和f2()都能很好的工作(在Java7版本之后)。我们可以很安全的将Fruit及其子类型作为'Fruit或者<? super Fruit>`的参数。
下面是一段类型分析。

public class GenericReading {
    static <T> T readExact(List<T> list) {
        return list.get(0);
    }

    static List<Apple> apples = Arrays.asList(new Apple());
    static List<Fruit> fruits = Arrays.asList(new Fruit());

    static void f1() {
        Apple a = readExact(apples);
        Fruit f = readExact(fruits);
        f = readExact(apples);
    }

    static class Reader<T> {
        T readExact(List<T> list) {
            return list.get(0);
        }
    }

    static void f2() {
        Reader<Fruit> fruitReader = new Reader<>();
        Fruit f = fruitReader.readExact(fruits);
        // Fruit a = fruitReader.readExact(apples); Error
    }

    static class CovariantReader<T> {
        T readCovariant(List<? extends T> list) {
            return list.get(0);
        }
    }

    static void f3() {
        CovariantReader<Fruit> fruitReader = new CovariantReader<>();
        Fruit f = fruitReader.readCovariant(fruits);
        Fruit a = fruitReader.readCovariant(apples);
    }

    public static void main(String[] args) {
        f1();
        f2();
        f3();
    }
}

上面的代码中，f1()用了精确的类型，因此如果使用了这个没有任何通配符的精确类型，就可以向List中写入和读取这个精确类型。另外，对于返回值，静态的泛型方法readExact()可以有效地“适应”每个方法调用，并能够从List<Apple>中返回一个Apple，从List<Fruit>中返回一个Fruit，就像在f1()中看到的那样。因此，只是读取的时候，静态的泛型方法不需要协变类型。
但是，如果有个泛型类，那么当创建这个类的实例的时候，要为这个类确定类型参数。就像在f2()中看到的那样，fruitReader可以从List<Fruit>中读取一个Fruit，因为这就是它的确切类型，但是List<Apple>还应该产生Fruit对象，但是fruitReader不允许传入List<Apple>参数，因为参数是List<Fruit>类型，编译器不允许发生这种转换。
而为了修正这个问题，CovariantReader.readCovariant()方法将接受List<? extends T>，因此，从这个列表中读取一个T是安全的(因为这个列表的所有对象至少是一个T，并且可能是T导出来的对象)，所以在f3()中，可以从List<Apple>中读取Fruit了。