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

类型擦除

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

那么,什么是类型擦除?举个例子:

public class Test {

    public static void main(String[] args) {

        ArrayList list1 = new ArrayList();
        list1.add("abc");

        ArrayList list2 = new ArrayList();
        list2.add(123);

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

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

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

例如:

class Apple {  
    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是一个无限定的类型变量,所以用Object替换。如果类型变量T有限定,那么原始类型就是用第一个边界的类型变量替换。

比如:Apple类这样声明的话

public class Apple {}

那么原始类型就是Comparable

通配符

先来看一段代码:

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

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

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

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

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

在Java中,?表示通配符。

Java泛型中,经常能看见TEKV这些类型参数变量,这些都表示具体的一个Java类型,而?表示不确定的Java类型。List可以看成是ListList等各种泛型List的父类,而ListList没有父子关系。

例如:

@Test
public void test1() {
    List list1 = new ArrayList<>();
    List 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 list1 = new ArrayList<>();
        List 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  void print1(List 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,也就是说当上界通配符中的TObject时,那么?和上界通配符是等价的。所以他们有个共性,都是不能写入值(null除外),只能读取值,并且值的类型为T

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

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

举个例子:

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

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

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

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

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

}

class Cat extends Animal {

}

class Dog extends Animal {

}

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

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

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

// 使用泛型方法修改后, T被设置了边界,然后也同样不能进行添加元素(null 除外)
public  void addAll(List 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 ragdolls) {
        ragdolls.add(ragdoll);
    }
    
    public static void main(String[] args) {

        List 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 ragdolls) {
    ragdolls.add(ragdoll);
}

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

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

public class Ragdoll extends Cat {

    private Ragdoll ragdoll = new Ragdoll();

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

    public void addToList(List ragdolls) {
        ragdolls.add(ragdoll);
    }

    public static void main(String[] args) {

        List ragdolls = new ArrayList<>();
        List cats = new ArrayList<>();
        List animals = new ArrayList<>();
        List helloKitties = new ArrayList<>();
        List 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

你可能感兴趣的:(Java 泛型之类型擦除和通配符PECS原则)