JAVA 泛型意淫之旅（二）

编译器如何处理泛型

泛型类编译后长什么样？

接上文，JAVA 泛型意淫之旅1，成功迎娶白富美后，终于迎来了最振奋人心的一刻：造娃！造男娃还是造女娃？对于我们程序猿来说，谁还在乎是男娃女娃，只要是自己的娃，就是好娃！但不知道父母们是不是这么想的，我们先搞一个造娃类，问一问造出不同的娃，父母的态度是什么。

public class MakeBaby<T> {
    private T baby;

    public T getBaby() {
        return baby;
    }

    public void setBaby(T baby) {
        this.baby = baby;
    }
}

先造两个试一下

MakeBaby<Boy> boy = new MakeBaby<>();
MakeBaby<Girl> girl = new MakeBaby<>();
System.out.println("\"男娃女娃都行吗？\"" + "\"" + (boy.getClass() == girl.getClass()) + "\"");

造完了我们看下父母态度

​

为什么男娃女娃都一样呢？其实是编译器在编译 MakeBaby<T> 时，进行了类型擦除，即删除了参数类型，我们反编译下 MakeBaby<T> 类

​
从反编译结果可以看出，getBaby 返回的是 Object 类型，setBaby 赋值的也是 Object 类型，类型变量被擦除掉了。编译器编译后实际交付给 JVM 的是

public class MakeBaby {
    private Object baby;

    public Object getBaby() {
        return baby;
    }

    public void setBaby(Object baby) {
        this.baby = baby;
    }
}

所以无论是 MakeBaby<Boy> 还是 MakeBaby<Girl>, 最终生成的代码都是 MakeBaby.

如果有类型限定，擦除后会是什么样呢？和女神造娃怎么能只造出一个普通的娃呢，这娃以后必须得会撩妹！稍微修改一下 MakeBaby<T> 类，添加一个类型限定

public class MakeBaby<T extends PickUpGirl> {
    private T baby;

    public T getBaby() {
        return baby;
    }

    public void setBaby(T baby) {
        this.baby = baby;
    }
}

再来看一下生成的结果

​
getBaby 和 setBaby 的类型不再是 Object, 而是我们限定的 PickUpGirl 了。如果有多个类型限定会怎样呢？我们不但要保证娃以后会撩妹，还要能赚钱，算是对孩子的美好祝福吧。

public class MakeBaby<T extends PickUpGirl & MakeMoney> {
    ...
}

看一下生成的结果

​
为什么生成的类型不是 MakeMoney 而是 PickUpGirl 呢？我们把两个接口位置替换一下

public class MakeBaby<T extends MakeMoney & PickUpGirl> {
    ...
}

再来看一下

​
生成的类型变成了 MakeMoney.

泛型方法编译后长什么样？

普通的泛型方法类型擦除我们不再讨论，和上面的泛型类类型擦除规则相同，主要讨论下泛型方法在多态情况下的类型擦除。

假设我们生了一个男孩儿，男孩儿遗传了伟大父亲的众多基因，我们姑且先以遗传了父亲的相貌为例。

// 父亲类
public class Father<T> {
    private T majorFeature;

    public Father(){
        this.setMajorFeature(null);
    }

    public Father(T feature){
        this.setMajorFeature(feature);
    }

    public T getMajorFeature() {
        return majorFeature;
    }

    public void setMajorFeature(T majorFeature) {
        this.majorFeature = majorFeature;
    }
}

// 外表类
public class Appearance {
    private int FeaturesScore;

    public Appearance(int featuresScore){
        this.setFeaturesScore(featuresScore);
    }

    public int getFeaturesScore() {
        return FeaturesScore;
    }

    public void setFeaturesScore(int featuresScore) {
        FeaturesScore = featuresScore;
    }
}

// 孩子类
public class Boy extends Father<Appearance> {
    public void setMajorFeature(Appearance appearance) {
        if(appearance.getFeaturesScore() >= 6){
            super.setMajorFeature(appearance);
        }
    }
}

Father<Appearance> boy = new Boy();
// 调用的是 Boy 类的 setMajorFeature 方法，而不是 Father 类的 setMajorFeature
boy.setMajorFeature(new Appearance(8));

如果父亲颜值小于 6 分，还是任娃自由生长吧，如果父亲颜值大于 6 分，娃可以遗传一下父亲的帅气基因。

我们看下 Boy 类生成的了什么样的代码

​
从图中可以看到，生成了两个 setMajorFeature 方法，一个参数类型为 Appearance, 一个参数类型为 Object. 参数为 Object 类型的 setMajorFeature 方法被称之为桥方法。

boy 变量声明为 Father<Appearance> 类型，这个类型有一个 setMajorFeature(T majorFeature) 方法，类型擦除后为 setMajorFeature(Object majorFeature). 虚拟机用 boy 引用的对象访问这个方法，boy 引用的对象为一个 Boy 类型的实例，由于多态性，它会调用 Boy.setMajorFeature(Object majorFeature) 方法，即上图生成的桥方法。看下桥方法做了什么操作，

​
由图可知，首先桥方法将变量进行了强制类型转换，转换为了 Appearance 类型，接着又调用了 setMajorFeature(Appearance majorFeature) 方法。这就是我们想要的结果，boy.setMajorFeature 调用了最合适的方法。实际生成的桥方法为

public void setMajorFeature(Object appearance){
    setMajorFeature((Appearance)appearance);
}

总结：

1. 当泛型类的泛型变量没有类型限制时，类型擦除后所有的 T 被替换为 Object;
2. 当泛型类的类型变量有一个限定类型时，类型擦除后所有的 T 不再被替换为 Object，而是替换为限定的类型；
3. 当泛型类的类型变量有多个限定类型时，类型擦除后所有的 T 被替换为第一个限定的类型。
4. 为了保证多态性，编译时会生成桥方法；
5. 桥方法接收的参数为 Object 类型，为了保证类型的安全性，会进行强制类型转换；
6. 类型擦除发生在编译时，虚拟机中没有泛型，只有普通的类和方法。