Java泛型--解析泛型擦除机制

Java基础 专栏收录该内容
10 篇文章 0 订阅

(本文主要帮助应用Java泛型,并不太深入,仅根据本人在阅读Java编程思想泛型这一章节遇到的问题给出一些解释,JAVA小菜,错误难免)
一、泛型类:
泛型类只需要在声明类名后面加即可,其中T可换成其他任意字符。如:class Test(){}

二、泛型接口:
声明形式与使用方法与泛型类相同。

三、泛型方法:
声明泛型方法,只需将泛型参数列表置于返回值之前即可,例如:public void f(T x){}。
这里需要注意的是,泛型方法的返回值不能直接作为参数传递给另一个方法,例如有方法A,其声明为public int A(){}。另一泛型方法B,其声明为public void b(T x){}。那么不可以直接b(A())。这主要是因为泛型的擦除机制所引起的

四、泛型擦除机制(本文的主要知识点。前三点可能看完会有点疑惑,这将在第4点给出答案。)
1、问题引入,一个让人迷惑的泛型程序代码

public class ErasedTypeEquivalence
{
        public static void main(String[] args)
{
        Class c1=new ArrayList<String>.getClass();
        Class c2=new ArrayList<Integer>.getClass();
        System.out.println(c1==c2);
}
}/*这段代码的输出结果为true*/

这里让人疑惑的是ArrayList和ArrayList很容易让人认为是不同的类型。而实际上他们是相同的类型。原因就是下面要讲的Java泛型的擦除机制。

2、擦除机制带来的问题:
在Java中,无法在泛型代码内部获得任何有关泛型参数类型的信息(不过你可以获得它的类名)。

import java.util.*;
class Frob{}
class Fnorkle{}
class Quark<Q>{}
class Particle<POSITION,MOMENTUM>{}
public class Fanxing 
{
    public static void main(String[] args) 
    {
        List<Frob> list=new ArrayList<Frob>();
        Map<Frob, Fnorkle> map=new HashMap<Frob, Fnorkle>();
        Quark<Fnorkle> quark=new Quark<Fnorkle>();
        Particle<Long, Double> p=new Particle<Long, Double>();

        System.out.println(Arrays.toString(list.getClass()  .getTypeParameters()));
        System.out.println(Arrays.toString(map.getClass(). getTypeParameters()));   
        System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));     
        System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
    }
}/*输出结果:
[E]
[K, V]
[Q]
[POSITION, MOMENTUM]*/

这里输出的只是泛型在定义时候的那个字符,而没有输出泛型参数类型。

3、extends关键字。
问题引入,先看代码:

class HasF()
{
    public void f()
    {
       system.out.println() 
    }
}

class Manipulator<T>
{
    private T obj;
    public Manipulator(T x){    Obj=x;  }
    public void manipulate(){   obj.f() ;}
}

public class Manipulation
{
    public static void main(String[] args)
    {
        HasF hf=new HasF();
        Manipulator<HasF> manipulator=new Manipulator<HasF>(hf);
        manipulator.manipulate();
    }
}
/*这段代码将会产生错误,因为在类Manipulator 的manipulate 方法中,有obj.f();。如果在C++中,这段代码自然是不会报错,只要传入HasF即可(这被称为潜在类型机制),然而Java中有擦除机制,obj将被擦除为“Object”类型的,那么obj去调用f()自然是要报错。解决的办法就是使用extends关键字(当然,利用Java反射机制解决也可以,不过这里主要采用泛型的方法)。只要这么去定义Manipulator,这段程序便不会报错:class Manipulator<T extends HasF>。
*/

4、擦除机制的内部实现:
Java泛型擦除,分两个时间阶段:其一是编译期,也就是在你敲代码的时候;其二是编译后运行期,也就是你运行代码的时候。在编译期,编译器是可以知道泛型参数信息的(前面说没有办法获得泛型参数类型信息,这是因为获得泛型参数类型信息是需要函数的,函数只能在运行期才起作用),所以这段时间,Java的泛型就有点像C++的了,当然,只是有点。因为像下面这样的代码,Java无法通过编译,而C++可以(在3里说过C++有潜在类型机制,而Java没有)。如下:

class HasF{ public void f(){} }
    class Test<T>
{
    private T obj;
    public Test(T x){ obj=x; }
    public invokeF(){ obj.f(); }//这里报错,无法通过编译
}
class TestMain()
{
    HasF hasF=new HasF();
    Test<HasF> test=new Test<HasF>(hasF);
    test.invokeF();
}

可能你会感到疑惑,既然编译器在编译期能够知道泛型参数的类型,那么理应向C++泛型那样给你编译通过才是,但为何这里不给编译通过,而是给你报了个编译错误?原因就是在运行期,将会发生泛型的擦除。发生擦除之后,上面的Test类代码将变成下面这样:

class Test
{
    private Object obj;
    public Test(Object x){ obj=x; }
    public invokeF(){ obj.f(); }    //这里必然报错
}

于是聪明的编译器在编译期就给你报了错,使你立即去修改你的代码,而不是等到代码运行的时候。
擦除机制一定就是把泛型参数擦除为Object吗?不是的。泛型擦除遵循下面这条规则:有限定的擦除为限定类型,无限定的擦除为Object。上述情形就是无限定的情形。接下来看看有限定的情形,同样把上面的Test类的T修改为T extends HasF。擦除之后Test类的代码变为:

    class Test
    {
        private HasF obj;
        public Test(HasF x){ obj=x; }
        public invokeF(){ obj.f(); }    //这里obj是HasF类型,所以此时这里便正确了
    }

最后再扩展一下,泛型多重限定的擦除,先在增加一个类:
class HasG{ public g(){} }
然后把Test类修改为多重限定,即:

class Test<T extends HasF & HasG>
{
    private T obj;
    public Test(T x){ obj=x; }
    public invokeF(){ obj.f(); }
    public invokeF(){ obj.g(); }
}

由于加了限定,此时代码是正确的。那么这种情况下,在运行时,怎么擦除?擦除之后的代码如下:

class Test<T extends HasF & HasG>
{
    private HasF obj;
    public Test(HasF x){ obj=x; }
    public invokeF(){ obj.f(); }
    public invokeF(){ ((HasG) obj).g(); }       //这里发生了个强转
}

看到这里,你应该可以得出这样的一个结论,泛型参数在运行时会被擦除,所以它所起的作用仅仅是在编译期提醒你,你应该使用什么类型的参数,从而在编译期避免引入错误的类型。

5、泛型中创建数组的推荐方式:Array.newInstance()

6、擦除补偿:
擦除补偿,主要是在类里面包含一个泛型的参数,然后将一个类实例传递给这个参数。示例代码如下:

class Employee{}
class ClassAsFactory<T>
{
    T x;
    public ClassAsFactory(Class<T> kind)
    {
        try {
            x=kind.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public void getXName()
    {
        System.out.println(x.getClass().getSimpleName());
    }
}

public class Generic<T> 
{   
    public static void main(String[] args) 
    {
ClassAsFactory<Employee> 
fe=new ClassAsFactory<Employee>(Employee.class);
        fe.getXName();
    }
}

7、泛型数组:
①成功创建泛型数组的唯一方式是创建一个被擦除类型的数组,然后对其进行转型。例如ArrayList al=(ArrayList[])new ArrayList[10]。
②在进行数组转型时,需要注意数组转型也是Java向上向下转型的一种:
例如: Object objs[]=new Object[10];
   String strs[]=(String[])objs;
这将产生错误,因为把Object转为String明显是向下转型,而objs又不是通过String向上转型得来的,所以必然产生错误。若数组是向上转型,则正确。
例如:String strs[]=new String[10];
   Object objs[]=strs;
另外,在Java中数组也是一种对象,它是Object类型的。
③Java泛型数组:代码如下:

class GenreicArr
{
    public GenreicArr(){}
}

public class GenericArrayTest <T>
{
    private T[] array;

    public GenericArrayTest(int sz)
    {
        array=(T[])new Object[sz];
//array=(T[])new GenreicArr[sz];
    }

    public T[] rep(){return array;}

    public static void main(String[] args) 
    {
        try 
        {
            GenericArrayTest<GenreicArr>  
gai=new GenericArrayTest<GenreicArr>(10);
// System.out.println(Arrays.toString(gai.getClass().getTypeParameters()));
            Object oa=gai.rep();
            GenreicArr[] ga=gai.rep();//可通过编译,但是运行时发生错误。
        } catch (Exception e) {
            e.printStackTrace();
        }   
    }
}

从上面的分析我们可以得出这样的结论:在创建泛型数组时,需要注意
Java数组转型的问题,例如:GenreicArr[] ga=gai.rep(),虽然可以通过编译
但是这里的泛型数组是这样的:array=(T[])new Object[sz],是Object类型的,所以这里是一个向下转型。虽然在泛型中,这可以通过编译,但是在运行时,依然会报错。若把GenericArrayTest的构造函数的第一行代码注释掉,把被注释的第二行代码打开,那就不会报错了。
④更好的创建Java泛型的方式:
在上面代码中,我们是这样创建泛型数组的,先泛化定义T[] array,然后再在GenericArrayTest实例化的时候立即强转:array=(T[])new Object[sz],这可能导致数组实际类型的丢失,因为数组一创建出来就立即被转型了。如:array=(T[])new Object[sz]中,Object数组一创建出来就立马被强转了(若这里的Object是一个自定义类型,而T是其父类,那这自定义类型将丢失)。所以,一个更好的方式是定义array的时候,将array定义为Object[],即
Object[] array=new Object[size]。当需要使用的时候,再进行强转,所以上面的rep函数可以这么去重写:public T[] rep(){return(T[]) array;}。可以看见这种方式似乎更显得灵活些,而且这种方式更符合我们的编码习惯:我们可以按照一般方式去创建数组,在需要泛型的时候将其进行强转即可。而且这种方式可以让我们更加清楚数组运行时的类型(这句话的意思是,例如有个自定义的User类,上面的array定义为User[] array=new User[size],一目了然,array数组运行时的类型就是User类型。当你阅读JDK中ArrayList等类的源码的时候,你会发现,里面大量采用了③中所说的创建泛型数组的方式,正如Think in java中所说Java类库中出现的某些惯用方法,并不代表这就是正确的解决之道,你不能认为它就是应该在你代码中遵循的示例)。
8、泛型边界(通配符):
Java泛型边界主要有三种:上界,下界,无界。
① 下界类似前面所说的extends关键字,只是“T ”换成了“?”。
首先,先来看一个令人感到迷惑的问题,且看下面代码:

 class Fruit{}
 class Apple extends Fruit{}
 public class Puzzle
 {
    public static void main(String[] args)
    {
        //下面的代码将发生错误
        ArrayList<Fruit> flist = new ArrayList<Apple>();
    } 
 }

这段代码里,有个令人困惑的问题:
Java泛型不是有擦除机制么,那么ArrayList与ArrayList应该相同类型的才对,即都会被擦除为ArrayList。事实上也确实如此,因为当你这么做:
System.out.println(ArrayList.getClass()==ArrayList.getClass())
你将会发现输出结果为true。而且在编译期,编译器是知道泛型参数类型的,那么为何这段代码会发生错误?其实这里隐含地涉及一个向下转型的问题。
Java泛型的主要目标之一就是将这种错误检测转移到编译期。所以,ArrayList flist,编译器可以知道Fruit的类型,从而在编译期限定你flist应该存放Fruit及其子类对象,否则发生编译错误。
那么可能有人会说,ArrayList flist = new ArrayList()应该没问题啊,Apple是Fruit的子类。实际上,编译器对代码的了解很少。当你在定义一个ArrayList,实际上ArrayList,ArrayList()与ArrayList将在运行时被擦除为相同的代码。从这点来看,似乎
ArrayList flist = new ArrayList()也应当可以。事实上,“<>”内的泛型参数,只是为了让你知道,你的ArrayList要存放什么东西,并通过编译期报错来告诉你,你可能存放了你预期之外的对象。像ArrayList flist = new ArrayList(),这段代码你究竟是想放什么对象到flist?你可能会说,都差不多。如果两种都可以放,那到时候取出对象的时候,你怎么知道你取出的是Fruit还是Apple对象?而且恰好此时你正要进行一个向下转型,或者你此时取出但是一个Fruit对象,而你想把它转为Apple,那么此时就要出错了。为了准确,你应该告诉编译器更多的信息。所以你应当做如下修改:ArrayList

interface HasColor{ java.awt.Color getColor(); }
class Dimension{ public int x,y,z; }
class ColorDimension<T extends Dimension & HasColor>
{
    T item;
    ColorDimension(T item){ this.item=item; }
    int getX(){ return item.x; }
    int getY(){ return item.y; }
    int getZ(){ return item.z; }
    java.awt.Color color(){ return item.getColor(); }
}

为了简单,这里只继承了两层,当然还可以继承三层乃至更多。除此之外,泛型参数还能实现接口。应当注意到HasColor是一个接口。于是还能这样:
class ColorDimension
{
代码略
}

②上界,也叫逆变。跟下界类似,只不过把extends关键字换成super。

class Fruit{}
class Apple extends Fruit{}
class Jonathan extends Apple{}
class SuperTypeWildCards
{
    public static void writeTo()
    {
        List<? super Apple> apples1=new ArrayList<Fruit>();
        List<? extends Apple> apples2=new ArrayList<Jonathan>();
       //apples1.add(new Fruit());  //报错
        apples1.add(new Jonathan());
        apples2.add(null);
    }
}

apples2为何只能放null的原因在上面已经说过,不再赘述。这里可能你会感到很奇怪,为什么apples1,不是应当放的是Apple的超类么?怎么却放了Apple的子类?而且放超类还报错!原因跟apples2只能放null是一样的,还是因为类型安全的问题:
当你往apples添加Apple的子类对象,当你把这些对象向上转型为apples所限定的基类,如此例,往apples添加了Jonathan,当你把Jonathan对象向上转型为Apple或者Fruit,都是安全的。而当你往apples添加Fruit对象的时候,此时你也想把这个对象朝apples所限定的方向去转型,那么此时将可能发生向下转型!因为Apple和Fruit都是Apple的超类,若允许你放Fruit,同时也放了Apple,那么你如何去分辨哪些是Apple哪些是Fruit?若此时需要转型为Apple,而正好你取到的对象是Fruit,此时就是把Fruit转型为Apple,这将导致错误。

③无界(通配符),无界被限定为单一边界:
无界通配符,可以接受范围更加宽泛的泛型参数:接受所有类型。如:

List<?> apples=new ArrayList<Fruit>();
List<?> apples=new ArrayList<Apple>();
List<?> apples=new ArrayList<Jonathan>();

此时可以发现无论是子类还是父类对象都可以被apples接受。当然apples.add方法能接收的参数只能是null,原因同上。

9、几个泛型所带来的问题:
①基本类型不能作为泛型参数,例如ArrayList是不允许的,不过java对基本类型都有包装类
②实现参数化接口(基类劫持接口),例如:

interface Payable<T>{}
class Employee implements Payable<Employee>{}
class Hourly extends Employee implements Payable<Hourly>{}

这里Hourly将不能编译,因为擦除会将Payable与Payable简化为相同的类Payable。这就意味着Hourly实现了两次Payable接口。但是有个有趣的现象,当你把Payble去掉泛型,Hourly则编译通过。
③重载问题:

public UserList<W,T>
{
void f(List<T> t){}
void f(List<W> w){}
}

这段代码将无法编译。

10、自限定类型
自限定其实就是让泛型参数只能接受自己的类型,例如:

class SelBounded<T extends SelBounded<T>>{}

自限定的价值在于可以产生协变参数类型。

扩展补充:
一、参数协变:
1、 方法覆盖的问题:

Classclass Base{}
class Derived extends Base{}
interface OrdinaryGetter{ Base get(); }
interface DerivedGetter extends OrdinaryGetter{ Derived get(); }

这里OrdinaryGetter的get方法将被DerivedGetter的get方法覆盖,这是完全合乎逻辑的,然而在早期的Java版本,却是不合法的。解决之道,就是参数协变(这是针对早期Java版本而言的)。
2、 方法重载的问题:

class OrdinarySetter
{
    void set(Base base)
    {
        System.out.println("OrdinarySetter.set(Base)");
    }
}

class DerivedSetter extends OrdinarySetter
{
    void set(Derived derived)
    {
        System.out.println("DerivedSetter.set(Derived)");
    }
}

class OrdinaryArguments
{
    public static void main(String[] args)
    {
        Base base =new Base();
        Derived derived=new Derived();
        DerivedSetter ds=new DerivedSetter();
        ds.set(base);
        ds.set(derived);
    }
}/*输出结果:OrdinarySetter.set(Base)
DerivedSetter.set(Derived)*/

说明基类的get还存在,DerivedSetter重载了get方法,即DerivedSetter有两个get方法。使用参数协变,将可以实现覆盖,从而使得DerivedSetter仅拥有一份自己的方法。将代码进行修改,

class OrdinarySetter<T extends OrdinarySetter>
{
    void set(T base)
    {
        System.out.println("OrdinarySetter.set(Base)");
    }
}
class DerivedSetter extends OrdinarySetter<DerivedSetter>{}

二、类型擦除与多态冲突和解决方法:桥方法
(本段摘自博客:http://blog.csdn.net/lonelyroamer/article/details/7868820
现在有这样一个泛型类:

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();  
    }  
}  

在这个子类中,我们设定父类的泛型类型为Pair,在子类中,我们覆盖了父类的两个方法,我们的原意是这样的:
将父类的泛型类型限定为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();  
}  

先来分析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,我们的本意是将泛型类变为如下:

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代码,这样的代码是无法通过编译器的检查的,但是虚拟机却是允许这样做的,因为虚拟机通过参数类型和返回类型来确定一个方法,所以编译器为了实现泛型的多态允许自己做这个看起来“不合法”的事情,然后交给虚拟器去区别。

参考资料:①Java编程思想
②博客:http://blog.csdn.net/lonelyroamer/article/details/7868820

  • 2
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值