Java 范型实现原理

一、Java泛型的实现方法：类型擦除

在最开始的时候已经简单介绍了一下，现在在回顾一下：

泛型思想早在C++语言的模板（Templates）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。例如在哈希表的存取中，JDK 1.5之前使用HashMap的get()方法，返回值就是一个Object对象，由于Java语言里面所有的类型都继承于java.lang.Object，那Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会被转嫁到程序运行期之中。
　　泛型技术在C#和Java之中的使用方式看似相同，但实现上却有着根本性的分歧，C#里面泛型无论在程序源码中、编译后的IL中（Intermediate Language，中间语言，这时候泛型是一个占位符）或是运行期的CLR中都是切实存在的，List<int>与List<String>就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型被称为真实泛型。
　　Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经被替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此对于运行期的Java语言来说，ArrayList<int>与ArrayList<String>就是同一个类。所以说泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型被称为伪泛型。

正确理解泛型概念的首要前提是理解类型擦出（type erasure）。Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方，但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式之间的重要区别。

很多泛型的奇怪特性都与这个类型擦除的存在有关，包括：

• 泛型类并没有自己独有的Class类对象。比如并不存在List<String>.class或是List<Integer>.class，而只有List.class。
• 静态变量是被泛型类的所有实例所共享的。对于声明为MyClass<T>的类，访问其中的静态变量的方法仍然是 MyClass.myStaticVar。不管是通过new MyClass<String>还是new MyClass<Integer>创建的对象，都是共享一个静态变量。
• 泛型的类型参数不能用在Java异常处理的catch语句中。因为异常处理是由JVM在运行时刻来进行的。由于类型信息被擦除，JVM是无法区分两个异常类型MyException<String>和MyException<Integer>的。对于JVM来说，它们都是 MyException类型的。也就无法执行与异常对应的catch语句。

可以通过两个简单的例子，来证明java泛型的类型擦除。

例1、

public class Test4 {public static void main(String[] args) {ArrayList<String> arrayList1=new ArrayList<String>();arrayList1.add("abc");ArrayList<Integer> arrayList2=new ArrayList<Integer>();arrayList2.add(123);System.out.println(arrayList1.getClass()==arrayList2.getClass());}}

在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整形。最后，我们通过arrayList1对象和arrayList2对象的getClass方法获取它们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

例2、

public class Test4 {public static void main(String[] args) throws IllegalArgumentException, SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {ArrayList<Integer> arrayList3=new ArrayList<Integer>();arrayList3.add(1);//这样调用add方法只能存储整形，因为泛型类型的实例为IntegerarrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");for (int i=0;i<arrayList3.size();i++) {System.out.println(arrayList3.get(i));}}

在程序中定义了一个ArrayList泛型类型实例化为Integer的对象，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明了Integer泛型实例在编译之后被擦除了，只保留了原型类型。

二、类型擦除后保留的原始类型

在上面，两次提到了原始类型，什么是原始类型？原始类型（raw type）就是擦除去了类型参数的泛型类型的名字。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。

比如：

例3：

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 void setFirst(T first) {this.first = first;}public T getSecond() {return second;}public void setSecond(T second) {this.second = second;}}

Pair<T>的原始类型为：

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 void setFirst(Object  first) {this.first = first;}public Object  getSecond() {return second;}public void setSecond(Object  second) {this.second = second;}}

因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。其结果就是一个普通的类，如同泛型加入java变成语言之前已经实现的那样。在程序中可以包含不同类型的Pair，如Pair<String>或Pair<Integer>，但是，擦除类型后它们就成为原始的Pair类型了。

从上面的那个例2中，我们也可以明白ArrayList<Integer>被擦除类型后，原始类型也变成了Object，所以通过反射我们就可以存储字符串了。

如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。

比如Pair这样声明

例4：

public class Pair<T extends Comparable& Serializable> {

那么原始类型就是Comparable

注意：

如果Pair这样声明public class Pair<T extends Serializable&Comparable> ，那么原始类型就用Serializable替换，而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

三、翻译泛型表达式

因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？就比如ArrayList<String>存储了一些字符串，而它被类型擦除后，原始类型为Object，那么为什么我们获取的时候，可以直接以String str=arrayList.get(1)这样的形式获取呢？

这是因为当程序调用这些泛型方法的时候，如果返回类型被擦除了，编译器会自动插入强制类型转换。

以上面例3的Pair<T>举例说明：

例5：

Pair<Date> pair=new Pair<Date>();    Date date=pair.getFirst();

getFirst的读出将返回Object类型。编译器会自动插入Date的强制类型转换，而不需要我们自己去强转。

当存取一个泛型域时也会自动插入强制类型转换。假设Pair类的first和second域都是public的，那么，表达式：

Date date=pair.first

也会自动地在结果字节码中插入强制类型转换。

四、翻译泛型方法（重点）

类型擦除也会出现在泛型方法中。

1、先检查，在编译

理解泛型方法，首先要明白java编译器会先检查代码中泛型的类型，然后再进行类型擦除，在进行编译的。

举个例子说明：

public static  void main(String[] args) {ArrayList<String> arrayList=new ArrayList<String>();arrayList.add("123");arrayList.add(123);//编译错误}

在上面的程序中，使用add方法添加一个整形，在eclipse中，直接就会报错，说明这就是在编译之前的检查。因为如果是在编译之后检查，类型擦除后，原始类型为Object，是应该运行任意引用类型的添加的。可实际上却不是这样，这恰恰说明了关于泛型变量的使用，是会在编译之前检查的。

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

现在有这样一个泛型类：

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

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

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

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

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

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

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

分析：

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

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

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

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

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

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>，我们的本意是将泛型类变为如下：

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子类的字节码，结果如下：

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方法如下：

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

而子类重写的方法是：

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

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

关于协变：。。。。。。

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

-

分享到：QQ空间新浪微博腾讯微博人人网网易微博QQ收藏百度云搜藏0

相关解决方案