泛型（二）

边界

• 泛型边界不但可以强制规定泛型可以应用的类型，还允许泛型按照其边界类型调用方法。

通配符

逆变与协变用来描述类型转换后的继承关系，其定义为：如果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)相互之间没有继承关系。

• 在Java中，数组是协变的

class Fruit {}
class Apple extends Fruit {}
class Jonathan extends Apple {}
class Orange extends Fruit {}

public class Test {
    public static void main(String[] args) {
        Fruit[] fruits = new Apple[10];
        fruits[0] = new Apple();
        fruits[1] = new Jonathan();
        try {
            fruits[0] = new Fruit(); // Runtime Error
        } catch (Exception e) {
            System.out.println(e);
        }
        try {
            fruits[1] = new Orange(); // Runtime Error
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

上述代码可以通过编译，但是在运行时会报错。

由于早期Java不支持泛型，对数组的通用操作都是使用Object[]实现的，因此上述代码可以通过编译。但是为了避免因为声明类型和实际类型不一致而引发的问题，Java把类型检查放在了运行时

然而使用泛型时，由于擦除的存在，所有检查都必须在编译期完成，因此诸如List<Fruit> flist = new ArrayList<Apple>;的代码是无法通过编译的。与数组不同，泛型没有内建的协变类型。

但是这一限制可以使用通配符解除，例如List<? extends Fruit> flist = new ArrayList<Apple>;，这不意味着flist可以持有任意Fruit及其子类的对象，仍然需要指明其持有类型，并向上转型。

此时问题又出现了，向上转型后将无法传入任何类型对象给flist，因为编译器不知道<? extends Fruit>指向哪个类型（此时编译器会将其标记为某种未知类型），例如它可以指向Orange，那么向其中放入Apple、Fruit、Object对象都是非法的。不过此时从flist中取出Apple对象是允许的（前提是容器中有对象）。

class Gen<T> {
    T t;

    public Test(T t) {
        // this.t = t;
        setT(t);
    }
    T getT() {
        return t;
    }
    void setT(T t) {
        this.t = t;
    }
}
class Fruit {}
class Apple extends Fruit {}

public class Test {
    public static void main(String[] args) throws Exception {
        Gen<? extends Number> g = new Gen<>(new Apple());
        g.setT(new Apple()); // error
    }
}
// Cannot infer type arguments for Test1<>
// The method setT(capture#2-of ? extends Number) in the type Test1<capture#2-of ? extends Number> is not applicable for the arguments (Apple)

在上面代码中，在构造方法中却是正确的。个人推测，new Gen<>(new Apple())这部分实际上泛型是Apple，并且也不能是包含通配符的泛型，因此构造方法顺利通过编译，但是变量g的泛型是包含通配符的，即其泛型是不确定的类型，因此后续调用setT()方法出现问题。

逆变

• 使用超类型通配符可以允许向持有某种类型的容器中写入其子类，即指定泛型<? super ClassName>，甚至可以使用类型参数<? super T>（但不能针对类型参数给出一个超类型边界<T super ClassName>）。

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

下面代码中writeExact()无法将Apple对象放入List<Fruit>中，即使是允许的。而使用了超类型通配符的writeWithWildcard()则以把Apple对象放入List<Fruit>。

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()); // Error
    }
    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item);
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruits, new Apple());
    }
}

相对应的，读取的代码可以使用子类型通配符，使读取对象时实现向上转型。

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 a = fruitReader.readExact(apples); // Error
    }
    static class CovariantReader<T> {
        T readCovariant(List<? extends T> list) {
            return list.get(0);
        }
    }
    static void f3() {
        CovariantReader<Fruit> fruitCovariantReader = new CovariantReader<>();
        Fruit f = fruitCovariantReader.readCovariant(fruits);
        Fruit a = fruitCovariantReader.readCovariant(apples);
    }
}

在上面的代码中，静态方法readExact()由于类型参数由list决定，所以正确返回了Apple对象并向上转型。如果只是读取，可以不使用泛型。而在f2()中，由于创建泛型类时先指定了类型参数为Fruit，因此Reader#readExact()不能接受List<Apple>参数。此时使用子类通配符即可解决问题。

无界通配符

• 使用无界通配符表示，当前不知道（或者不需要知道）具体类型，但是不影响对其进行操作。例如可以从List<?>中取值出来（但是会丢失类型信息），不可以向其中写入。

捕获转换

• 如果向一个使用<?>的方法传递原生类型，对于编译器来说，可能会推断出实际的类型参数，使得这个方法可以回转并调用另一个使用这个确切类型的方法，即捕获转换。

public class Main {
    static <T> T f1(List<T> list) {
        T t = list.get(0);
        return t;
    }

    static void f2(List<?> list) {
        f1(list);
    }

    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(0);
        f1(list);
        f2(list);
    }
}

上面代码中，main()方法中调用f1(list)是有警告的，而经过f2()的捕获转换后警告消失了。