Java泛型中的PECS原则

转载

日薪灬越亿 2022-11-30 17:21:01

先来看一个错误：

List<? extends Foo> list1 = new ArrayList<Foo>();
List<? extends Foo> list2 = new ArrayList<Foo>();

 /* Won't compile */
 list2.add( new Foo() ); //error 1
 list1.addAll(list2);    //error 2

error 1:

IntelliJ says:

add(capture<? extends Foo>) in List cannot be applied to add(Foo)

The compiler says:

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>

error 2:

IntelliJ gives me

addAll(java.util.Collection<? extends capture<? extends Foo>>) in List cannot be applied to addAll(java.util.List<capture<? extends Foo>>)

Whereas the compiler just says

cannot find symbol
symbol  : method addAll(java.util.List<capture#692 of ? extends Foo>)
location: interface java.util.List<capture#128 of ? extends Foo>
        list1.addAll(list2);

下面会一步一步，逐步推导出，为什么会出现上面的错误，以及背后的原因

泛型不是协变的

在 Java 语言中，数组是协变的，也就是说，如果 Integer 扩展了 Number，那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求 Number[] 的地方完全可以传递或者赋予 Integer[]。（更正式地说，如果 Number是 Integer 的超类型，那么 Number[] 也是 Integer[]的超类型）。但是在泛型类型中 List< Number> 不是 List< Integer> 的超类型，也就是说在需要 List< Number> 的地方不能传递 List< Integer>。为啥呢？如果不这么做，将破坏要提供的类型安全泛型。

泛型是为了在编译期，检查参数类型的是否正确。如果子类赋值给超类，将破坏了类型安全

对于数组来说，String[] 是可以赋值给Object[]：

public class Test {
    public static void main(String[] args) {
        String[] strArray = new String[3];
        Object[] objArray = strArray;
    }
}

集合这么写就会有编译错误：

public class Test {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        // 编译 Error:(14, 32) java: 不兼容的类型: java.util.List<java.lang.String>无法转换为java.util.List<java.lang.Object>
        List<Object> objList = strList; 
    }
}

PECS法则

在泛型不是协变中提到，在使用 List< Number> 的地方不能传递 List< Integer>，那么有没有办法能让他两兼容使用呢？答案是：有，可以使用通配符。

主要是 extends 和 super 关键字。比如：

HashMap< T extends String>;
HashMap< ? extends String>;
HashMap< T super String>;
HashMap< ? super String>;

主要涉及的是Java泛型中重要的PECS法则：

? extends T

类型的上界是 T，参数化类型可能是 T 或 T 的子类：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? extends Fruit> fruits = new ArrayList<>();
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile error
        fruits.add(new Apple());    // compile error

        fruits = new ArrayList<Fruit>(); // compile success
        fruits = new ArrayList<Apple>(); // compile success
        fruits = new ArrayList<Food>(); // compile error
        fruits = new ArrayList<? extends Fruit>(); // compile error: 通配符类型无法实例化  

        Fruit object = fruits.get(0);    // compile success
    }
}

存入数据：

赋值是参数化类型为 Fruit 的集合和其子类的集合都可以成功，通配符类型无法实例化。
编译器会阻止将Strawberry类加入fruits。在向fruits中添加元素时，编译器会检查类型是否符合要求。因为编译器只知道fruits是Fruit某个子类的List，但并不知道这个子类具体是什么类，为了类型安全，只好阻止向其中加入任何子类。
那么可不可以加入Fruit呢？很遗憾，也不可以。事实上，不能往使用了? extends的数据结构里写入任何的值。

读取数据

但是，由于编译器知道它总是Fruit的子类型，因此我们总可以从中读取出Fruit对象：

Fruit fruit = fruits.get(0);

? super T

表示类型的下界是 T，参数化类型可以是 T 或 T 的超类：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? super Fruit> fruits = new ArrayList<>();
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile success
        fruits.add(new Apple());    // compile success

        fruits = new ArrayList<Fruit>(); // compile success
        fruits = new ArrayList<Apple>(); // compile error
        fruits = new ArrayList<Food>(); // compile success
        fruits = new ArrayList<? super Fruit>(); // compile error: 通配符类型无法实例化      

        Fruit object = fruits.get(0); // compile error
    }
}

存入数据：

super 通配符类型同样不能实例化，Fruit 和其超类的集合均可赋值
这里 add 时 Fruit 及其子类均可成功，为啥呢？因为已知 fruits 的参数化类型必定是 Fruit 或其超类 T，那么 Fruit 及其子类肯定可以赋值给 T。
出于对类型安全的考虑，我们可以加入Apple对象或者其任何子类（如RedApple）对象（因为编译器会自动向上转型），但由于编译器并不知道List的内容究竟是Apple的哪个超类，因此不允许加入特定的任何超类型。