泛型代码和虚拟机
虚拟机没有泛型类型对象—所有对象都属于普通类。
接下来的部分,你将看到编译器是如何“擦除”类型参数的?这个过程对Java程序员有什么影响?
1.类型擦除
无论何时定义一个泛型类型,都自动提供了一个相应的原始类型(raw type)。原始类型的名字就是删除类型参数后的泛型类型名。类型变量被擦除(erased),并被其限定类型替代(无限定的变量用Object)。
例如,泛型类型Pair<T>
:
public class Pair<T> {
private T first;
private T second;
public Pair(){
first = null;
second = null;
}
public Pair(T first, T second){
this.first = first;
this.second = second;
}
public T getFirst(){
return first;
}
public T getSecond(){
return second;
}
public void setFirst(T newValue){
first = newValue;
}
public void setSecond(T newValue){
second = newValue;
}
}
其原始类型:
public class Pair {
private Object first;
private Object second;
public Pair(){
first = null;
second = null;
}
public Pair(Object first, Object second){
this.first = first;
this.second = second;
}
public Object getFirst(){
return first;
}
public Object getSecond(){
return second;
}
public void setFirst(Object newValue){
first = newValue;
}
public void setSecond(Object newValue){
second = newValue;
}
}
因为T是一个未限定的类型变量,它只是被Object替换了。
结果是一个普通类,就像泛型引入Java语言之前你已经实现的一样。
你的程序可能包含不同的Pair类型,如Pair<String>
或Pair<LocalDate>
,但是擦除使它们都变成了原始的Pair类型。
原始类型用第一个限定类型替换类型变量,没有给定限定类型用Object替换类型变量。例如,在类Pair<T>
中的类型变量没有显式的限定,因此原始类型用Object替换T。假设我们声明了一个稍微不同的类型:
public class Interval<T extends Comparable & Serializable> implements Serializable {
private T lower;
private T upper;
public Interval(T first, T second){
if (first.compareTo(second) <= 0){
lower = first;
upper = second;
}
else {
lower = second;
upper = first;
}
}
}
泛型类Interval的原始类型:
public class Interval implements Serializable {
private Comparable lower;
private Comparable upper;
public Interval(Comparable first, Comparable second){
if (first.compareTo(second) <= 0){
lower = first;
upper = second;
}
else {
lower = second;
upper = first;
}
}
}
注意:
你可能想要知道切换限定:class Interval<T extends Serializable & Comparable>
会发生什么。如果这样做,原始类型用Serializable替换T,而编译器在必要时要向Comparable插入强制类型转换。为了提高效率,应该将标签(tagging)接口(即没有方法的接口)放在限定列表的末尾。
2.翻译泛型表达式
当程序调用一个泛型方法时,当返回类型被擦除后,编译器会插入强制类型转换。例如,下面的语句序列:
Pair<Employee> buddies = ...;
Employee buddy = buddies.getFirst();
擦除getFirst的返回类型后,有返回类型Object。编译器自动插入Employee的强制类型转换。即,编译器把这个方法调用翻译为两条虚拟机指令:
- 对原始方法Pair.getFirst的调用
- 将返回的Object类型强制转换为Employee类型。
当访问一个泛型域时也要插入强制类型转换。假设Pair类的first域和second域都是公有的(这也许不是一种好的编程风格,但在Java中是合法的)。表达式:
Employee buddy = buddies.first;
也会在结果字节码中插入强制类型转换。
3.翻译泛型方法
类型擦除也会出现在泛型方法中。程序员通常认为一个泛型方法:
public static <T extends Comparable> T min(T[] a)
是一个完整的方法族,但擦除类型之后,只剩下一个方法:
public static Comparable min(Comparable[] a)
注意,类型参数T已经被擦除了,只留下了它的限定类型Comparable。
方法的擦除带来了一些复杂性。看下面这个示例:
public class DateInterval extends Pair<LocalDate> {
public DateInterval(){}
public DateInterval(LocalDate first, LocalDate second){
super(first, second);
}
public void setSecond(LocalDate second){
if (second.compareTo(getFirst()) >= 0){
super.setSecond(second);
}
}
}
一个日期区间是一对LocalDate对象,并且想要在该类中覆盖父类的Pair<T>
的setSecond(T second)来确保第二个值永远不小于第一个值。这个类被擦除后变成:
public class DateInterval extends Pair {
public DateInterval(){}
public DateInterval(LocalDate first, LocalDate second){
super(first, second);
}
public void setSecond(LocalDate second){
if (second.compareTo(getFirst()) >= 0){
super.setSecond(second);
}
}
}
也许令人惊讶的是,存在另一个从Pair继承的setSecond方法,即
public void setSecond(Object newValue){
second = newValue;
}
这两个方法:
public void setSecond(LocalDate second)//想要覆盖的方法
public void setSecond(Object newValue)//继承而来的方法
显然是不同的方法,因为它有不同类型的参数:Object和LocalDate。
出现setSecond(Object newValue)
方法原因是:因为编译阶段Pair<LocalDate>
已经被类型擦除为Pair了,其setSecond方法变成了setSecond(Object newValue)
,所以DateInterval中的setSecond(LocalDate second)
是无法覆盖父类的setSecond(Object newValue)
的。
考虑下面的语法序列:
DateInterval interval = new DateInterval(LocalDate.of(2017,1,1), LocalDate.of(2017,8,1));
Pair<LocalDate> pair = interval;
pair.setSecond(LocalDate.of(2017, 9, 1));
我们的期望是,setSecond的调用是多态的,并且最适合的方法被调用。即我们的期望是:pair.setSecond(LocalDate.of(2017, 9, 1))
调用的方法应该是DateInterval的setSecond(Object newValue),因为pair的类型为Pair<LocalDate>
且有方法setSecond(Object newValue)。但是由于类型擦除导致子类并没有覆盖掉父类方法Pair的setSecond(Object second)而出现了的两个DateInterval.setSecond方法,进而导致这里的pair.setSecond(LocalDate)调用了DateInterval的setSecond(LocalDate),从而干扰了多态。排除这种干扰的关键在于,要成功的覆盖的父类方法Pair的setSecond(Object second)。
要解决这个问题,编译器会自动在DateInterval类中生成一个桥方法(bridge method):
public void setSecond(Object second){
setSecond((LocalDate) second);
}
这样,桥方法就覆盖了泛型父类Pair的setSecond(Object second)了。对于多态来说就没有问题了。
要想了解它的工作过程,请仔细地跟踪下面语句的执行:
pair.setSecond(LocalDate.of(2017, 9, 1));
变量pair已经声明为类型Pair<LocalDate>
,并且这个类型只有一个简单的方法叫setSecond,即setSecond(Object)。虚拟机用pair引用的对象调用这个方法。这个对象是DateInterval类型,因而将会调用DateInterval.setSecond(Object)方法。这个方法是合成的桥方法。该方法调用DateInterval.setSecond(LocalDate),这正是我们所期望的操作效果。
桥方法可能会变得十分奇怪。假设DateInterval类也覆盖了getSecond方法:
public LocalDate getSecond() {
return (LocalDate) super.getSecond();
}
由于需要桥方法来覆盖父类中的getSecond,编译器会自动在DateInterval中生成一个桥方法:
public Object getSecond(){
getSecond();
}
在擦除的类型中,有两个getSecond方法:
LocalDate getSecond()//想要覆盖的方法
Object getSecond()//编译器覆盖父类的方法产生的桥方法
不能这样编写Java代码。具有相同参数类型(它们都没有参数)的两个方法是不合理的。但是,在虚拟机中,用参数类型和返回类型指定一个方法。因此,编译器可能产生两个仅返回类型不同的方法字节码,虚拟机能够正确处理这一情况。
注意:
桥方法不仅用于泛型类型,在一个方法覆盖另一个方法时可以指定一个更严格的返回类型。例如:
public class Employee implements Cloneable {
public Employee clone() throws CloneNotSupportedException { ... }
}
Object.clone和Employee.clone方法被说成是具有协变的返回类型(covariarant return types)。
实际上,Employee类有两个克隆方法:
Employee.clone()// 定义
Object.clone() // 覆盖了Object.clone
合成的桥方法调用了新定义的方法。
总之,需要记住有关Java泛型转换的事实:
- 虚拟机中没有泛型,只有普通的类和方法。
- 所有的类型参数都用它们的限定类型替换。
- 桥方法被合成来保持多态。
- 为保持类型安全性,必要时插入强制类型转换。