类型擦除
泛型是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
。这说明泛型类型String
和Integer
在编译期间都被擦除掉了,只剩下原始类型。
原始类型:就是擦除了泛型信息,最后在字节码中的真正的类型,类型参数会擦除到它的第一个边界,并使用其限定类型(无限定的变量用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[]
;
泛型是不变的,并且泛型会在编译期间会进行类型擦除,所以List
和List
是并列的关系,不存在子父类关系,那么如果想让泛型也可以协变起来,那该怎么办呢?这个时候,就需要用到我们的通配符了。
在Java中,?
表示通配符。
Java泛型中,经常能看见T
、E
、K
、V
这些类型参数变量,这些都表示具体的一个Java类型,而?
表示不确定的Java类型。List>
可以看成是List
、List
等各种泛型List
的父类,而List
和List
没有父子关系。
例如:
@Test
public void test1() {
List list1 = new ArrayList<>();
List
然而,上述编译能够通过,但是list
是受限的,比如,不能使用add()
,但是get()
不受影响,这是因为?
的类型是不确定的,所以不能添加元素(null
除外),而取出的元素是Object
类型的。list
不能添加元素,是不是就没什么用了呢,其实还是有用处的,例如下面的例子:
public class Demo {
@Test
public void test1() {
List list1 = new ArrayList<>();
List
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 animals = new ArrayList<>();
// 将另一个动物集合添加到动物对象的集合中
public void addAll(List animalList) {
for (Animal animal : animalList) {
this.animals.add(animal);
}
}
}
然后现在有一个Cat
类和一个Dog
类都继承于Animal
类,现在需要将Cat
集合或者Dog
集合放入动物集合,如果直接放入addAll()
方法,会直接飘红报错,因为List
和List
不存在父子关系:
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 extends Animal> 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 super Ragdoll> 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 super Ragdoll> 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
;