转自:http://blog.csdn.net/lonelyroamer/article/details/7868820
参考:java核心技术
一、Java泛型的实现方法:类型擦除
前面已经说了,Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢?因为,在编译期间,所有的泛型信息都会被擦除掉。正确理解泛型概念的首要前提是理解类型擦出(type erasure)。
Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会在编译器在编译的时候去掉。这个过程就称为类型擦除。
如在代码中定义的List<object>和List<String>等类型,在编译后都会编程List。JVM看到的只是List,而由泛型附加的类型信息对JVM来说是不可见的。Java编译器会在编译时尽可能的发现可能出错的地方,但是仍然无法避免在运行时刻出现类型转换异常的情况。类型擦除也是Java的泛型实现方法与C++模版机制实现方式之间的重要区别。
可以通过两个简单的例子,来证明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());
- }
- }
例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方法只能存储整形,因为泛型类型的实例为Integer
- arrayList3.getClass().getMethod("add", Object.class).invoke(arrayList3, "asd");
- for (int i=0;i<arrayList3.size();i++) {
- System.out.println(arrayList3.get(i));
- }
- }
二、类型擦除后保留的原始类型
在上面,两次提到了原始类型,什么是原始类型?原始类型(raw type)就是擦除去了泛型信息,最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型,相应的原始类型都会被自动地提供。类型变量被擦除(crased),并使用其限定类型(无限定的变量用Object)替换。
例3:
- class Pair<T> {
- private T value;
- public T getValue() {
- return value;
- }
- public void setValue(T value) {
- this.value = value;
- }
- }
- class Pair {
- private Object value;
- public Object getValue() {
- return value;
- }
- public void setValue(Object value) {
- this.value = value;
- }
- }
从上面的那个例2中,我们也可以明白ArrayList<Integer>被擦除类型后,原始类型也变成了Object,所以通过反射我们就可以存储字符串了。
如果类型变量有限定,那么原始类型就用第一个边界的类型变量来替换。
比如Pair这样声明
例4:
- public class Pair<T extends Comparable& Serializable> {
注意:
如果Pair这样声明public class Pair<T extends Serializable&Comparable> ,那么原始类型就用Serializable替换,而编译器在必要的时要向Comparable插入强制类型转换。为了提高效率,应该将标签(tagging)接口(即没有方法的接口)放在边界限定列表的末尾。
要区分原始类型和泛型变量的类型
在调用泛型方法的时候,可以指定泛型,也可以不指定泛型。
在不指定泛型的情况下,泛型变量的类型为 该方法中的几种类型的同一个父类的最小级,直到Object。
在指定泛型的时候,该方法中的几种类型必须是该泛型实例类型或者其子类。
- public class Test2{
- public static void main(String[] args) {
- /**不指定泛型的时候*/
- int i=Test2.add(1, 2); //这两个参数都是Integer,所以T为Integer类型
- Number f=Test2.add(1, 1.2);//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Number
- Object o=Test2.add(1, "asd");//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Object
- /**指定泛型的时候*/
- int a=Test2.<Integer>add(1, 2);//指定了Integer,所以只能为Integer类型或者其子类
- int b=Test2.<Integer>add(1, 2.2);//编译错误,指定了Integer,不能为Float
- Number c=Test2.<Number>add(1, 2.2); //指定为Number,所以可以为Integer和Float
- }
- //这是一个简单的泛型方法
- public static <T> T add(T x,T y){
- return y;
- }
- }
其实在泛型类中,不指定泛型的时候,也差不多,只不过这个时候的泛型类型为Object,就比如ArrayList中,如果不指定泛型,那么这个ArrayList中可以放任意类型的对象。
举例:
- public static void main(String[] args) {
- ArrayList arrayList=new ArrayList();
- arrayList.add(1);
- arrayList.add("121");
- arrayList.add(new Date());
- }
三、类型擦除引起的问题及解决方法
因为种种原因,Java不能实现真正的泛型,只能使用类型擦除来实现伪泛型,这样虽然不会有类型膨胀的问题,但是也引起了许多新的问题。所以,Sun对这些问题作出了许多限制,避免我们犯各种错误。
1、先检查,在编译,以及检查编译的对象和引用传递的问题
既然说类型变量会在编译的时候擦除掉,那为什么我们往ArrayList<String> arrayList=new ArrayList<String>();所创建的数组列表arrayList中,不能使用add方法添加整形呢?不是说泛型变量Integer会在编译时候擦除变为原始类型Object吗,为什么不能存别的类型呢?既然类型擦除了,如何保证我们只能使用泛型变量限定的类型呢?
java是如何解决这个问题的呢?java编译器是通过先检查代码中泛型的类型,然后再进行类型擦除,在进行编译的。举个例子说明:
- public static void main(String[] args) {
- ArrayList<String> arrayList=new ArrayList<String>();
- arrayList.add("123");
- arrayList.add(123);//编译错误
- }
那么,这么类型检查是针对谁的呢?我们先看看参数化类型与原始类型的兼容
- ArrayList arrayList=new ArrayList();
- ArrayList<String> arrayList=new ArrayList<String>();
如果是与以前的代码兼容,各种引用传值之间,必然会出现如下的情况:
- ArrayList<String> arrayList1=new ArrayList(); //第一种 情况
- ArrayList arrayList2=new ArrayList<String>();//第二种 情况
这样是没有错误的,不过会有个编译时警告。
不过在第一种情况,可以实现与 完全使用泛型参数一样的效果,第二种则完全没效果。
因为,本来类型检查就是编译时完成的。new ArrayList()只是在内存中开辟一个存储空间,可以存储任何的类型对象。而真正涉及类型检查的是它的引用,因为我们是使用它引用arrayList1 来调用它的方法,比如说调用add()方法。所以arrayList1引用能完成泛型类型的检查。
而引用arrayList2没有使用泛型,所以不行。
举例子:
- public class Test10 {
- public static void main(String[] args) {
- //
- ArrayList<String> arrayList1=new ArrayList();
- arrayList1.add("1");//编译通过
- arrayList1.add(1);//编译错误
- String str1=arrayList1.get(0);//返回类型就是String
- ArrayList arrayList2=new ArrayList<String>();
- arrayList2.add("1");//编译通过
- arrayList2.add(1);//编译通过
- Object object=arrayList2.get(0);//返回类型就是Object
- new ArrayList<String>().add("11");//编译通过
- new ArrayList<String>().add(22);//编译错误
- String string=new ArrayList<String>().get(0);//返回类型就是String
- }
- }
通过上面的例子,我们可以明白,类型检查就是针对引用的,谁是一个引用,用这个引用调用泛型方法,就会对这个引用调用的方法进行类型检测,而无关它真正引用的对象。
从这里,我们可以再讨论下 泛型中参数化类型为什么不考虑继承关系
在Java中,像下面形式的引用传递是不允许的:
- ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误
- ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误
我们先看第一种情况,将第一种情况拓展成下面的形式:
- ArrayList<Object> arrayList1=new ArrayList<Object>();
- arrayList1.add(new Object());
- arrayList1.add(new Object());
- ArrayList<String> arrayList2=arrayList1;//编译错误
在看第二种情况,将第二种情况拓展成下面的形式:
- ArrayList<String> arrayList1=new ArrayList<String>();
- arrayList1.add(new String());
- arrayList1.add(new String());
- ArrayList<Object> arrayList2=arrayList1;//编译错误
所以,要格外注意,泛型中的引用传递的问题。
2、自动类型转换
因为类型擦除的问题,所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题,既然都被替换为原始类型,那么为什么我们在获取的时候,不需要进行强制类型转换呢?看下ArrayList和get方法:
- public E get(int index) {
- RangeCheck(index);
- return (E) elementData[index];
- }
看以看到,在return之前,会根据泛型变量进行强转。
写了个简单的测试代码:
- public class Test {
- public static void main(String[] args) {
- ArrayList<Date> list=new ArrayList<Date>();
- list.add(new Date());
- Date myDate=list.get(0);
- }
然后反编了下字节码,如下
- public static void main(java.lang.String[]);
- Code:
- 0: new #16 // class java/util/ArrayList
- 3: dup
- 4: invokespecial #18 // Method java/util/ArrayList."<init
- :()V
- 7: astore_1
- 8: aload_1
- 9: new #19 // class java/util/Date
- 12: dup
- 13: invokespecial #21 // Method java/util/Date."<init>":()
- 16: invokevirtual #22 // Method java/util/ArrayList.add:(L
- va/lang/Object;)Z
- 19: pop
- 20: aload_1
- 21: iconst_0
- 22: invokevirtual #26 // Method java/util/ArrayList.get:(I
- java/lang/Object;
- 25: checkcast #19 // class java/util/Date
- 28: astore_2
- 29: return
看第22 ,它调用的是ArrayList.get()方法,方法返回值是Object,说明类型擦除了。然后第25,它做了一个checkcast操作,即检查类型#19, 在在上面找#19引用的类型,他是
9: new #19 // class java/util/Date
是一个Date类型,即做Date类型的强转。
所以不是在get方法里强转的,是在你调用的地方强转的。
附关于checkcast的解释:
checkcast checks that the top item on the operand stack (a reference to an object or array) can be cast to a given type. For example, if you write in Java:
return ((String)obj);
then the Java compiler will generate something like:
aload_1 ; push -obj- onto the stack
checkcast java/lang/String ; check its a String
areturn ; return it
checkcast is actually a shortand for writing Java code like:
if (! (obj == null || obj instanceof <class>)) {
throw new ClassCastException();
}
// if this point is reached, then object is either null, or an instance of
// <class> or one of its superclasses.
3、类型擦除与多态的冲突和解决方法
现在有这样一个泛型类:
- class Pair<T> {
- private T value;
- public T getValue() {
- return value;
- }
- public void setValue(T value) {
- this.value = value;
- }
- }
然后我们想要一个子类继承它
- class DateInter extends Pair<Date> {
- @Override
- public void setValue(Date value) {
- super.setValue(value);
- }
- @Override
- public Date getValue() {
- return super.getValue();
- }
- }
将父类的泛型类型限定为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;
- }
- }
- @Override
- public void setValue(Date value) {
- super.setValue(value);
- }
- @Override
- public Date getValue() {
- return super.getValue();
- }
我们在一个main方法测试一下:
- public static void main(String[] args) throws ClassNotFoundException {
- DateInter dateInter=new DateInter();
- dateInter.setValue(new Date());
- dateInter.setValue(new Object());//编译错误
- }
为什么会这样呢?
原因是这样的,我们传入父类的泛型类型是Date,Pair<Date>,我们的本意是将泛型类变为如下:
- class Pair {
- private Date value;
- public Date getValue() {
- return value;
- }
- public void setValue(Date value) {
- this.value = value;
- }
- }
可是由于种种原因,虚拟机并不能将泛型类型变为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这两个桥方法的意义又有不同。
setValue方法是为了解决类型擦除与多态之间的冲突。
而getValue却有普遍的意义,怎么说呢,如果这是一个普通的继承关系:
那么父类的setValue方法如下:
- public ObjectgetValue() {
- return super.getValue();
- }
- public Date getValue() {
- return super.getValue();
- }
关于协变:。。。。。。
并且,还有一点也许会有疑问,子类中的巧方法 Object getValue()和Date getValue()是同 时存在的,可是如果是常规的两个方法,他们的方法签名是一样的,也就是说虚拟机根本不能分别这两个方法。如果是我们自己编写Java代码,这样的代码是无法通过编译器的检查的,但是虚拟机却是允许这样做的,因为虚拟机通过参数类型和返回类型来确定一个方法,所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情,然后交给虚拟器去区别。
4、泛型类型变量不能是基本数据类型
不能用类型参数替换基本类型。就比如,没有ArrayList<double>,只有ArrayList<Double>。因为当类型擦除后,ArrayList的原始类型变为Object,但是Object类型不能存储double值,只能引用Double的值。
5、运行时类型查询
举个例子:
- ArrayList<String> arrayList=new ArrayList<String>();
因为类型擦除之后,ArrayList<String>只剩下原始类型,泛型信息String不存在了。
那么,运行时进行类型查询的时候使用下面的方法是错误的
- if( arrayList instanceof ArrayList<?>)
? 是通配符的形式 ,将在后面一篇中介绍。
6、异常中使用泛型的问题
1、不能抛出也不能捕获泛型类的对象。事实上,泛型类扩展Throwable都不合法。例如:下面的定义将不会通过编译:
- public class Problem<T> extends Exception{......}
- try{
- }catch(Problem<Integer> e1){
- 。。
- }catch(Problem<Number> e2){
- ...
- }
- try{
- }catch(Problem<Object> e1){
- 。。
- }catch(Problem<Object> e2){
- ...
- try{
- }catch(Exception e1){
- 。。
- }catch(Exception e2){//编译错误
- ...
2、不能再catch子句中使用泛型变量
- public static <T extends Throwable> void doWork(Class<T> t){
- try{
- ...
- }catch(T e){ //编译错误
- ...
- }
- }
- public static <T extends Throwable> void doWork(Class<T> t){
- try{
- ...
- }catch(T e){ //编译错误
- ...
- }catch(IndexOutOfBounds e){
- }
- }
但是在异常声明中可以使用类型变量。下面方法是合法的。
- public static<T extends Throwable> void doWork(T t) throws T{
- try{
- ...
- }catch(Throwable realCause){
- t.initCause(realCause);
- throw t;
- }
7、数组(这个不属于类型擦除引起的问题)
不能声明参数化类型的数组。如:
- Pair<String>[] table = newPair<String>(10); //ERROR
- Object[] objarray =table;
- objarray ="Hello"; //ERROR
- objarray =new Pair<Employee>();
8、泛型类型的实例化
不能实例化泛型类型。如,
- first = new T(); //ERROR
不能建立一个泛型数组。
- public<T> T[] minMax(T[] a){
- T[] mm = new T[2]; //ERROR
- ...
- }
类似的,擦除会使这个方法总是构靠一个Object[2]数组。但是,可以用反射构造泛型对象和数组。
利用反射,调用Array.newInstance:
- publicstatic <T extends Comparable> T[]minmax(T[] a)
- {
- T[] mm == (T[])Array.newInstance(a.getClass().getComponentType(),2);
- ...
- // 以替换掉以下代码
- // Obeject[] mm = new Object[2];
- // return (T[]) mm;
- }
1、
- class Pair<T> {
- public boolean equals(T value) {
- return null;
- }
- }
booleanequals(String); //在Pair<T>中定义
boolean equals(Object); //从object中继承
但是,这只是一种错觉。实际上,擦除后方法
boolean equals(T)
变成了方法 boolean equals(Object)
这与Object.equals方法是冲突的!当然,补救的办法是重新命名引发错误的方法。
2、
泛型规范说明提及另一个原则“要支持擦除的转换,需要强行制一个类或者类型变量不能同时成为两个接口的子类,而这两个子类是同一接品的不同参数化。”
下面的代码是非法的:
- class Calendar implements Comparable<Calendar>{ ... }
- class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{...} //ERROR
这一限制与类型擦除的关系并不很明确。非泛型版本:
- class Calendar implements Comparable{ ... }
- class GregorianCalendar extends Calendar implements Comparable{...} //ERROR
10、泛型在静态方法和静态类中的问题
泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数
举例说明:
但是要注意区分下面的一种情况: