基础说明

虚拟机没有泛型类型对象一所有对象都属于普通类。在泛型实现的早期版本中，甚至能够将使用泛型的程序编译为在1.0虚拟机上运行的类文件！
由于泛型是在1.5才引入的，为了兼容，在java文件编译后是肯定看不见泛型的。也就是类型擦除，下面就来介绍一下类型擦除

---

类型擦除

无论何时定义一个泛型类型，都会自动提供一个相应的原始类型（raw type)。这个原始
类型的名字就是去掉类型参数后的泛型类型名。类型变量会被擦除(erased),并替换为其限
定类型（或者，对于无限定的变量则替换为Object)。

---

无限定

下面先来看下面的代码

public class MyTool<T> {
    private T info;

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }
}

这就是很简单的一个泛型类。现在，我通过反射来查看T是什么类型。

    public static void main(String[] args) throws NoSuchMethodException {
        // 得到getInfo方法
        Method getInfo = MyTool.class.getDeclaredMethod("getInfo");
        System.out.println("getInfo返回值类型为："+getInfo.getReturnType().getName());
    }

上面运行结果如下

可以发现如果没有指定泛型，那么在编译过后T被替换为了Object
即使我们指定了泛型，T还是会被替换为Object

    public static void main(String[] args) throws NoSuchMethodException {
        MyTool<Comparable> myTool = new MyTool<>();
        // 得到getInfo方法
        Method getInfo = myTool.getClass().getDeclaredMethod("getInfo");
        System.out.println("getInfo返回值类型为：" + getInfo.getReturnType().getName());
    }

---

有限定

上面的泛型类没有限制，下面来看一下有限定的情况

public class Tool<T extends Serializable> {

    private T info;

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }
}

还是使用反射来查看T类型

        // 得到getInfo方法
        Method getInfo = Tool.class.getDeclaredMethod("getInfo");
        System.out.println("getInfo返回值类型为："+getInfo.getReturnType().getName());

运行结果如下

可以发现限定符替换了T。
上面是一个限定符的，如果有两个或者多个限定符呢

public class MulTool<T extends Comparator & Comparable & Serializable> {

    public T t;

    public T getInfo() {
        return t;
    }
}

还是使用上面的反射代码，输出如下

可以发现返回的是Comparator，下面来交换一下限定的位置，分别让Comparable 和Serializable成为第一个（自己交换即可）。交换后代码运行结果如下

通过上面的运行结果，我们就可以得出结论，使用了类型限定符，那么第一个限定就会替换T

---

转换泛型表达式

还是上利用MyTool代码举例

public class MyTool<T> {
    private T info;

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }
}

我们经过上面的学习，知道会进行类型擦除，上面的MyTool的T会被替换为Object。那么getInfo返回值就是Object的类型，但是我们在实际调用getInfo方法时只要传入了类型，那么返回值就是我们传入的类型。看下面代码

    public static void main(String[] args) {
        MyTool<String> stringMyTool = new MyTool<>();
        stringMyTool.setInfo("xxx");
        // 得到所有方法
        Method[] declaredMethods = stringMyTool.getClass().getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName(); // 方法名
            String returnType = declaredMethod.getReturnType().getName(); // 返回类型
            System.out.println("方法名：" + methodName + "--返回类型：" + returnType);
        }
        // 返回的类型为String
        String info = stringMyTool.getInfo();
    }

运行结果如下

可以发现getInfo返回值确实为Object，但是我们 String info = stringMyTool.getInfo(); 这条语句并没有进行强转，这就说明编译器已经帮我们进行了强转。其实在调用stringMyTool.getInfo()编译器将其转换为了2条虚拟机指令

• 对于MyTool.getInfo()的调用
• 将返回值Object强转为String

上面是对方法返回值进行强转，其实对字段的访问也是一样的，如果将info字段修饰符改为public，也可以直接使用String进行接收

        String filed = stringMyTool.info;

---

方法类型擦除（桥方法）

我们不说啥理论，直接看下面代码

public class Animal<T> {

    public void setX(T t) {
    }
}

这个一个泛型类，有一个set方法

public class Cat extends Animal<String> {

    @Override
    public void setX(String s) {
        
    }
}

这是Cat类，继承了Animal类，指定了泛型为String，并且重写了setX方法。

下面就是使用Cat

        Animal<String> animal = new Cat();
        animal.setX("hello world!!!");

大家看看这个代码，有没有发现问题？我们使用Animal来接收了一个Cat对象，这是正确的。但是animal.serX就不怎么对劲了。下面我来分析一下

• 由于Animal会发生类型擦除，所以animal.setX实际会调用 Animal.setX(Object)
• 由于animal引用的是一个Cat，所以会去寻找Cat.setX(Object)
• 问题出现了，Cat根本没有setX(Object)，只有setX(String)

可以发现，类型擦除和多态产生了冲突。为了解决这个问题，编译器会在Cat类中生成一个桥方法。在Cat中生成的桥方法如下

    public void setX(Object s){
        setX((String) s);
    }

其实就是生成了一个参数为Object类型的setX方法，这个方法会去调用参数为String类型的方法，就好像桥梁的作用一样，所以我们成为桥方法。

为了验证上面的说法，也就是编译器会给我们的代码生成一个桥方法，下面我就使用反射输出Cat的所有方法。

    public static void main(String[] args) {
        // 得到所有方法
        Method[] declaredMethods = Cat.class.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName(); // 方法名
            // 参数类型集合
            List<String> types = Arrays.stream(declaredMethod.getParameterTypes())
                    .map(Class::getTypeName).collect(Collectors.toList());
            System.out.println("方法名：" + methodName + "--参数类型：" + types);
        }
    }

上面的代码输出如下

可以发现编译器确实给我们生成了一个setX方法，参数类型就是Object，这个方法就是一个桥方法。有了这个桥方法，多态和类型擦除的问题也就解决了。

---

关于重载的一些说明

通过上面的例子，大家应该对桥方法有了清晰的认识，有些思想活跃的人可能就会觉得不太对劲了。大家回想一下重载的定义，重载就是参数名相同，参数不同。

这确实没问题，下面我在Animal定义应该getT方法，然后在Cat里面重写这个方法

public class Animal<T> {

    private T t;

    public void setX(T t) {
    }

    public T getT() {
        return t;
    }
}

public class Cat extends Animal<String> {

    @Override
    public void setX(String s) {

    }

    @Override
    public String getT() {
        return "";
    }
}

根据上面的桥方法，大家想一下，是不是在Cat里面会生成应该 public Object getT()方法呢？我们还是通过的反射代码查看，代码和运行结果如下

    public static void main(String[] args) {
        // 得到所有方法
        Method[] declaredMethods = Cat.class.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            String methodName = declaredMethod.getName(); // 方法名
            // 参数类型集合
            List<String> types = Arrays.stream(declaredMethod.getParameterTypes())
                    .map(Class::getTypeName).collect(Collectors.toList());
            // 得到返回类型
            String returnType = declaredMethod.getReturnType().getName();
            System.out.println("方法名：" + methodName + "\t\t参数类型：" + types + "\t\t返回类型：" + returnType);
        }
    }

可以发现，在Cat里面存在了2个同名的方法，并且参数相同，这已经违法了重载的定义，按理说程序应该直接报错，但是并没有，原因就是在虚拟机中，会由参数类型和返回类型共同指定一个方法，上面代码中参数为Object的getT方法就是一个桥方法。

---

总结

在最后，对于java泛型的转换，我们需要记住以下几点

• 虚拟机中没有泛型，只有普通的类和方法
• 所有的类型参数都会替换为它们的限定类型
• 会通过合成桥方法来保持多态
• 为保持类型安全性，必要时会插入强制类型转换

关于泛型的更多知识，参考以下内容

泛型程序设计基础
类型擦除、桥方法、泛型代码和虚拟机
泛型的限制及其继承规则
泛型的通配符(extends,super,?)