【java】--泛型-类型擦除与多态的冲突和解决方法

类型擦除与多态的冲突和解决方法

现在有这样一个泛型类：

[java] view plain copy

print ?

1. class Pair<T> {  
2.     private T value;  
3.     public T getValue() {  
4.         return value;  
5.     }  
6.     public void setValue(T value) {  
7.         this.value = value;  
8.     }  
9. }  

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

然后我们想要一个子类继承它

[java] view plain copy

print ?

1. class DateInter extends Pair<Date> {  
2.     @Override  
3.     public void setValue(Date value) {  
4.         super.setValue(value);  
5.     }  
6.     @Override  
7.     public Date getValue() {  
8.         return super.getValue();  
9.     }  
10. }  

class DateInter extends Pair<Date> {
	@Override
	public void setValue(Date value) {
		super.setValue(value);
	}
	@Override
	public Date getValue() {
		return super.getValue();
	}
}

在这个子类中，我们设定父类的泛型类型为Pair<Date>，在子类中，我们覆盖了父类的两个方法，我们的原意是这样的：

将父类的泛型类型限定为Date，那么父类里面的两个方法的参数都为Date类型：“

[java] view plain copy

print ?

1. public Date getValue() {  
2.     return value;  
3. }  
4. public void setValue(Date value) {  
5.     this.value = value;  
6. }  

	public Date getValue() {
		return value;
	}
	public void setValue(Date value) {
		this.value = value;
	}

 
所以，我们在子类中重写这两个方法一点问题也没有，实际上，从他们的@Override标签中也可以看到，一点问题也没有，实际上是这样的吗？

分析：

实际上，类型擦除后，父类的的泛型类型全部变为了原始类型Object，所以父类编译之后会变成下面的样子：

[java] view plain copy

print ?

1. class Pair {  
2.     private Object value;  
3.     public Object getValue() {  
4.         return value;  
5.     }  
6.     public void setValue(Object  value) {  
7.         this.value = value;  
8.     }  
9. }  

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

再看子类的两个重写的方法的类型：

[java] view plain copy

print ?

1.        @Override  
2. public void setValue(Date value) {  
3.     super.setValue(value);  
4. }  
5. @Override  
6. public Date getValue() {  
7.     return super.getValue();  
8. }  

        @Override
	public void setValue(Date value) {
		super.setValue(value);
	}
	@Override
	public Date getValue() {
		return super.getValue();
	}

先来分析setValue方法，父类的类型是Object，而子类的类型是Date，参数类型不一样，这如果实在普通的继承关系中，根本就不会是重写，而是重载。
我们在一个main方法测试一下：

[java] view plain copy

print ?

1. public static void main(String[] args) throws ClassNotFoundException {  
2.         DateInter dateInter=new DateInter();  
3.         dateInter.setValue(new Date());                  
4.                 dateInter.setValue(new Object());//编译错误  
5.  }  

public static void main(String[] args) throws ClassNotFoundException {
		DateInter dateInter=new DateInter();
		dateInter.setValue(new Date());                
                dateInter.setValue(new Object());//编译错误
 }

如果是重载，那么子类中两个setValue方法，一个是参数Object类型，一个是Date类型，可是我们发现，根本就没有这样的一个子类继承自父类的Object类型参数的方法。所以说，却是是重写了，而不是重载了。

为什么会这样呢？

原因是这样的，我们传入父类的泛型类型是Date，Pair<Date>，我们的本意是将泛型类变为如下：

[java] view plain copy

print ?

1. class Pair {  
2.     private Date value;  
3.     public Date getValue() {  
4.         return value;  
5.     }  
6.     public void setValue(Date value) {  
7.         this.value = value;  
8.     }  
9. }  

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

然后再子类中重写参数类型为Date的那两个方法，实现继承中的多态。

可是由于种种原因，虚拟机并不能将泛型类型变为Date，只能将类型擦除掉，变为原始类型Object。这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。这样，类型擦除就和多态有了冲突。JVM知道你的本意吗？知道！！！可是它能直接实现吗，不能！！！如果真的不能的话，那我们怎么去重写我们想要的Date类型参数的方法啊。

于是JVM采用了一个特殊的方法，来完成这项功能，那就是桥方法。

首先，我们用javap -c className的方式反编译下DateInter子类的字节码，结果如下：

[java] view plain copy

print ?

1. class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {  
2.   com.tao.test.DateInter();  
3.     Code:  
4.        0: aload_0  
5.        1: invokespecial #8                  // Method com/tao/test/Pair."<init>"  
6. :()V  
7.        4: return  
8.   
9.   public void setValue(java.util.Date);  //我们重写的setValue方法  
10.     Code:  
11.        0: aload_0  
12.        1: aload_1  
13.        2: invokespecial #16                 // Method com/tao/test/Pair.setValue  
14. :(Ljava/lang/Object;)V  
15.        5: return  
16.   
17.   public java.util.Date getValue();    //我们重写的getValue方法  
18.     Code:  
19.        0: aload_0  
20.        1: invokespecial #23                 // Method com/tao/test/Pair.getValue  
21. :()Ljava/lang/Object;  
22.        4: checkcast     #26                 // class java/util/Date  
23.        7: areturn  
24.   
25.   public java.lang.Object getValue();     //编译时由编译器生成的巧方法  
26.     Code:  
27.        0: aload_0  
28.        1: invokevirtual #28                 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法  
29. ;  
30.        4: areturn  
31.   
32.   public void setValue(java.lang.Object);   //编译时由编译器生成的巧方法  
33.     Code:  
34.        0: aload_0  
35.        1: aload_1  
36.        2: checkcast     #26                 // class java/util/Date  
37.        5: invokevirtual #30                 // Method setValue:(Ljava/util/Date;   去调用我们重写的setValue方法  
38. )V  
39.        8: return  
40. }  

class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
  com.tao.test.DateInter();
    Code:
       0: aload_0
       1: invokespecial #8                  // Method com/tao/test/Pair."<init>"
:()V
       4: return

  public void setValue(java.util.Date);  //我们重写的setValue方法
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #16                 // Method com/tao/test/Pair.setValue
:(Ljava/lang/Object;)V
       5: return

  public java.util.Date getValue();    //我们重写的getValue方法
    Code:
       0: aload_0
       1: invokespecial #23                 // Method com/tao/test/Pair.getValue
:()Ljava/lang/Object;
       4: checkcast     #26                 // class java/util/Date
       7: areturn

  public java.lang.Object getValue();     //编译时由编译器生成的巧方法
    Code:
       0: aload_0
       1: invokevirtual #28                 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法
;
       4: areturn

  public void setValue(java.lang.Object);   //编译时由编译器生成的巧方法
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #26                 // class java/util/Date
       5: invokevirtual #30                 // Method setValue:(Ljava/util/Date;   去调用我们重写的setValue方法
)V
       8: return
}

从编译的结果来看，我们本意重写setValue和getValue方法的子类，竟然有4个方法，其实不用惊奇，最后的两个方法，就是编译器自己生成的桥方法。可以看到桥方法的参数类型都是Object，也就是说，子类中真正覆盖父类两个方法的就是这两个我们看不到的桥方法。而打在我们自己定义的setvalue和getValue方法上面的@Oveerride只不过是假象。而桥方法的内部实现，就只是去调用我们自己重写的那两个方法。

所以，虚拟机巧妙的使用了巧方法，来解决了类型擦除和多态的冲突。

不过，要提到一点，这里面的setValue和getValue这两个桥方法的意义又有不同。

setValue方法是为了解决类型擦除与多态之间的冲突。

而getValue却有普遍的意义，怎么说呢，如果这是一个普通的继承关系：

那么父类的setValue方法如下：

[java] view plain copy

print ?

1. public ObjectgetValue() {  
2.         return super.getValue();  
3.     }  

public ObjectgetValue() {
		return super.getValue();
	}

而子类重写的方法是：

[java] view plain copy

print ?

1. public Date getValue() {  
2.         return super.getValue();  
3.     }  

public Date getValue() {
		return super.getValue();
	}

其实这在普通的类继承中也是普遍存在的重写，这就是协变。

关于协变：。。。。。。

并且，还有一点也许会有疑问，子类中的巧方法  Object   getValue()和Date getValue()是同 时存在的，可是如果是常规的两个方法，他们的方法签名是一样的，也就是说虚拟机根本不能分别这两个方法。如果是我们自己编写Java代码，这样的代码是无法通过编译器的检查的，但是虚拟机却是允许这样做的，因为虚拟机通过参数类型和返回类型来确定一个方法，所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情，然后交给虚拟器去区别。