Java 泛型之类型擦除和通配符PECS原则

2021-04-09 本文已影响0人程序员汪汪

类型擦除

泛型是Java 5才引入的特性，在这之前，并没有泛型，所以Java的泛型和C++的不一样，是通过类型擦除来实现，是伪泛型，这可能为了兼容之前的版本，做出的无奈之举吧。

那么，什么是类型擦除？举个例子：

public class Test {

    public static void main(String[] args) {

        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("abc");

        ArrayList<Integer> list2 = new ArrayList<Integer>();
        list2.add(123);

        System.out.println(list1.getClass() == list2.getClass());
    }
}
/**
输出：
    true
*/

在这个例子中，我们分别定义了两个ArrayList集合，一个是ArrayList<String>，只能存储字符串；一个是ArrayList<Integer>，只能存储整数，然后我们通过getClass()获取它们的类的信息，并进行比较，发现为true。这说明泛型类型String和Integer在编译期间都被擦除掉了，只剩下原始类型。

原始类型：就是擦除了泛型信息，最后在字节码中的真正的类型，类型参数会擦除到它的第一个边界，并使用其限定类型（无限定的变量用Object）替换。

例如：

class Apple<T> {  
    private T value;  
    public T getValue() {  
        return value;  
    }  
    public void setValue(T  value) {  
        this.value = value;  
    }  
}

类型擦除后：

class Apple {  
    private Object value;  
    public Object getValue() {  
        return value;  
    }  
    public void setValue(Object  value) {  
        this.value = value;  
    }  
}

因为在Apple<T>中，T是一个无限定的类型变量，所以用Object替换。如果类型变量T有限定，那么原始类型就是用第一个边界的类型变量替换。

比如：Apple类这样声明的话

public class Apple<T extends Comparable> {}

那么原始类型就是Comparable。

通配符

先来看一段代码：

public static void main(String[] args) {
    // 编译报错
    // required ArrayList<Integer>, found ArrayList<Number>
    List<Integer> list1 = new ArrayList<>();
    List<Number> list2 = list1;

    // 可以正常通过编译,正常使用
    Integer[] arr1 = new Integer[]{1, 2};
    Number[] arr2 = arr1;
}

你可能会疑问，为什么数组可以进行类似向上转型的操作，而泛型不可以，这是因为Java中泛型是不变的，而数组是协变的。

因为数组是协变的，所以只要java中的A类是B类的父类，那么A[] a = new B[]；

泛型是不变的，并且泛型会在编译期间会进行类型擦除，所以List<Integer>和List<Number>是并列的关系，不存在子父类关系，那么如果想让泛型也可以协变起来，那该怎么办呢？这个时候，就需要用到我们的通配符了。

在Java中，?表示通配符。

Java泛型中，经常能看见T、E、K、V这些类型参数变量，这些都表示具体的一个Java类型，而?表示不确定的Java类型。List<?>可以看成是List<Object>、List<String>等各种泛型List的父类，而List<Object>和List<String>没有父子关系。

例如：

@Test
public void test1() {
    List<String> list1 = new ArrayList<>();
    List<Object> list2 = new ArrayList<>();

//    list2 = list1;  // 报错

    List<?> list = new ArrayList<>();
    list = list1;
    list = list2;    // 可以正常编译通过   
}

然而，上述编译能够通过，但是list是受限的，比如，不能使用add()，但是get()不受影响，这是因为?的类型是不确定的，所以不能添加元素（null除外），而取出的元素是Object类型的。list不能添加元素，是不是就没什么用了呢，其实还是有用处的，例如下面的例子：

public class Demo {

    @Test
    public void test1() {
        List<String> list1 = new ArrayList<>();
        List<Object> list2 = new ArrayList<>();

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

//        list.add("1");

        list1.add("123"); //String
        list1.add("456");
        list2.add(789); // Integer
        list2.add('C'); // Character

        list.add(null); // ok
        list.add("Str"); // error

        print(list1);
        print(list2);

    }

//   这是一个泛型方法，作用和print(List<?> list)是一样的，但是后者要简洁一点  
//    public <T extends Object> void print1(List<T> list) {
//        for (T t : list) {
//            System.out.println(t);
//        }
//    }

    public void print(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
}

PECS

在说PECS之前，先了解一下通配符的边界问题。前面使用的?，没有任何限制，一般被称为无界通配符，还有另外两种，上界通配符和下界通配符。

?：无界通配符
? extends T：上界通配符
? super T：下界通配符

PE，CS是producer extends，consumer super的缩写，这是Joshua Bloch在《Effective Java》一书中引入的一个略显奇怪的术语，但有助于理解泛型的用法。换言之，参数化类型代表生产者（producer）则使用extends，代表消费者（consumer）则使用super。简而言之，PECS就是指导我们正确使用泛型的上界通配符和下界通配符的。

上界通配符

?被称作无界通配符，并不是真的无界，它的默认实现是? extends Object，也就是说当上界通配符中的T为Object时，那么?和上界通配符是等价的。所以他们有个共性，都是不能写入值（null除外），只能读取值，并且值的类型为T。

? extends T对应协变关系，表示?必须是T或者T的子类。

PE原则，简单来说就是如果你的方法只是想从集合获取值，并且希望集合的类型范围是T及其子类，那么泛型可以定义为? extends T。

举个例子：

假如有个Animal类，里面有个addAll()方法，用来将另一个动物集合，放到动物对象的集合里。

public class Animal {
    // 动物集合
    private List<Animal> animals = new ArrayList<>();
    // 将另一个动物集合添加到动物对象的集合中
    public void addAll(List<Animal> animalList) {
        for (Animal animal : animalList) {
            this.animals.add(animal);
        }
    }
}

然后现在有一个Cat类和一个Dog类都继承于Animal类，现在需要将Cat集合或者Dog集合放入动物集合，如果直接放入addAll()方法，会直接飘红报错，因为List<Cat>和List<Animal>不存在父子关系：

public class Animal {
    // 动物集合
    private List<Animal> animals = new ArrayList<>();
    // 将另一个动物集合添加到动物对象的集合中
    public void addAll(List<Animal> animalList) {
        for (Animal animal : animalList) {
            this.animals.add(animal);
        }
    }

    public static void main(String[] args) {
        List<Cat> catList = new ArrayList<>();
        Animal fruit = new Animal();
        // 报错 不兼容的类型，List<Cat> 不能转换为 List<Animal>
        fruit.addAll(catList);
    }

}

class Cat extends Animal {

}

class Dog extends Animal {

}

那现在就是需要把这个放进去怎么办，这个时候就轮到上界通配符上场了。修改addAll方法，使用了上界通配符后，元素只能读，不能写，传入的类型范围是Animal或其子类集合，这里只有Animal符合要求。

// 使用上届通配符修改后，animalList不能进行添加元素（null除外）
public void addAll(List<? extends Animal> animalList) {
    for (Animal animal : animalList) {
        this.animals.add(animal);
    }
}

如果不使用上界通配符，那么使用泛型方法，也能达到同样的效果：

// 使用泛型方法修改后， T被设置了边界，然后也同样不能进行添加元素(null 除外)
public <T extends Animal> void addAll(List<T> animalList) {
    for (Animal animal : animalList) {
        this.animals.add(animal);
    }
}

有人可能会问了，这个上界通配符和PE原则有什么关系？当然有，PE是producer extends的缩写，addAll()方法的功能是从animalList这个集合中取出数据，然后将数据存入animals集合中，那么，对于addAll()方法来说，它消耗的是animalList，它是消费者，而animalList提供数据给它消费，那么animalList就是生产者（producer）。

PE原则就是针对方法来说的，如果某个方法的参数需要一个生产者，并且范围是某个类型的集合或者其子类的集合，那么这个时候使用上界通配符? extends 某个具体类型。

下界通配符

? super T对应逆变关系，使用了下界通配符? super T，只能写入值，不能取值，并且写入的值必须是T或者T的父类。

举个例子，现在我们有一个Ragdoll类，它继承于Cat类，而Cat又继承于Animal类，Ragdoll类中有一个addToList()方法，可以把Ragdoll对象添加到一个集合中去：

public class Ragdoll extends Cat {

    private Ragdoll ragdoll = new Ragdoll();

    public void addToList(List<Ragdoll> ragdolls) {
        ragdolls.add(ragdoll);
    }
    
    public static void main(String[] args) {

        List<Ragdoll> ragdolls = new ArrayList<>();
        Ragdoll ragdoll = new Ragdoll();
        // 将布偶猫对象添加到布偶猫的集合中去
        ragdoll.addToList(ragdolls); // Ok
    }
}

class Animal {
}

class Cat extends Animal {
}

class HelloKitty extends Cat {
}

class Dog extends Animal {
}

本来这样挺好，但是老板说，所有的布偶猫（Ragdoll），都要添加到一个动物集合中，并且，其他品种的猫以及其它动物都不能混进来！！！这个时候，就需要用到下界通配符改造addToList()方法，将它的接收范围扩大，传入的集合范围是Ragdoll或者是其父类集合。

使用? super T下界通配符改造addToList()：

public void addToList(List<? super Ragdoll> ragdolls) {
    ragdolls.add(ragdoll);
}

注意：T super 某个具体类型 是错误写法，是错误写法，是错误写法。

那么这个时候，是不是其他品种的猫以及其它动物都不能混进来？测试一下：

public class Ragdoll extends Cat {

    private Ragdoll ragdoll = new Ragdoll();

//    public void addToList(List<Ragdoll> ragdolls) {
//        ragdolls.add(ragdoll);
//    }

    public void addToList(List<? super Ragdoll> ragdolls) {
        ragdolls.add(ragdoll);
    }

    public static void main(String[] args) {

        List<Ragdoll> ragdolls = new ArrayList<>();
        List<Cat> cats = new ArrayList<>();
        List<Animal> animals = new ArrayList<>();
        List<HelloKitty> helloKitties = new ArrayList<>();
        List<Dog> dogs = new ArrayList<>();

        Ragdoll ragdoll = new Ragdoll();
        // 将布偶猫对象添加到布偶猫的集合或者更大的集合中去
        ragdoll.addToList(ragdolls); // Ok
        ragdoll.addToList(cats); // Ok
        ragdoll.addToList(animals); // Ok
        ragdoll.addToList(helloKitties); // error 报错
        ragdoll.addToList(dogs); // error 报错
    }
}

class Animal {

}

class Cat extends Animal {
}

class HelloKitty extends Cat {
}

class Dog extends Animal {
}

嗯嗯，满足需求，升职加薪指日可待了。。。

那么这个下界通配符，跟CS有什么关系？

CS是consumer super的缩写，对于addToList()来说，参数ragdolls在消耗（将Ragdoll对象添加到List中）方法内部的东西（Ragdoll对象），那么这时，参数ragdolls就是一个消费者（consumer）。

CS原则也是针对方法来说的，如果某个方法的参数需要消费方法内的东西，并且范围是某个类或者某个类的父类，那么这个时候使用下界通配符? super 某个具体类型。

PECS总结

简单归纳就是：

只从方法的形参集合获取值，那么使用? extends T；
只从方法的形参集合写入值，那么使用? super T；