Java泛型擦除与桥接方法 - 智猿学院-IT界的百科全书

Java 泛型擦除与桥接方法：一场你追我赶的魔术表演 🧙‍♂️

各位观众，欢迎来到今天的“Java 奇幻夜”！ 🧙‍♀️ 今天我们将要揭秘的是 Java 泛型世界中一个既神秘又充满魅力的现象：泛型擦除，以及它带来的“好朋友”——桥接方法。

准备好了吗？让我们一起踏上这场代码与魔法交织的旅程！ 🚀

开场白：泛型，你的“变形金刚” 🤖

在没有泛型的日子里，我们的代码就像一个杂货铺，什么都能往里塞，但每次取东西都得小心翼翼，生怕拿错了。

// 没有泛型的代码，就像一堆乱放的玩具
ArrayList list = new ArrayList();
list.add("Hello");
list.add(123);

String str = (String) list.get(0); // 需要强制类型转换，容易出错
Integer num = (Integer) list.get(1); // 同样需要强制转换

泛型的出现，就像给我们的代码注入了“变形金刚”的基因，让它可以根据需求变幻形态，保证类型安全。

// 有了泛型，类型安全，代码更清晰
ArrayList<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123); // 编译时就会报错，类型不匹配

String str = list.get(0); // 不需要强制类型转换，直接使用

你看，泛型就像一个“类型警察”，在编译时就帮你把关，防止你犯下类型错误。

第一幕：泛型擦除，一场华丽的“消失的魔术” 🎩

但是，等等！魔法并没有那么简单。你以为泛型真的像“类型警察”一样，无时无刻地守护着你的代码吗？

答案是：No!

Java 为了兼容之前的版本，耍了一个“障眼法”：泛型擦除 (Type Erasure)。

什么意思呢？

这意味着，在编译时，泛型类型信息会被“擦除”，替换成它的上限（如果没有指定上限，就替换成 Object）。

// 编译前的代码
ArrayList<String> list = new ArrayList<>();
list.add("Hello");

// 编译后的代码 (大致)
ArrayList list = new ArrayList();
list.add("Hello"); // 这里其实会被编译成 list.add((Object) "Hello");

String str = (String) list.get(0); // 获取时需要强制类型转换

看到了吗？泛型就像一个魔法师，在编译时华丽地表演了一场“消失的魔术”，把类型信息都“擦”掉了。

重点来了！

泛型擦除发生在编译阶段。 运行时，JVM 看到的只是普通的类和方法，没有泛型类型信息。
泛型擦除是为了兼容旧版本。 如果运行时也保留泛型信息，那么旧版本的 JVM 就无法运行新的代码了。

用表格总结一下：

特性	编译阶段	运行阶段
泛型类型信息	存在，用于类型检查	不存在，已被擦除
实际类型	`ArrayList<String>`，`List<Integer>` 等	`ArrayList`，`List` (底层都是 `Object`)

第二幕：桥接方法，一场“亡羊补牢”的戏码 🎭

泛型擦除虽然带来了兼容性，但同时也带来了一个问题：多态性 的破坏。

为了理解这个问题，我们先来看一个例子：

class Parent<T> {
    private T data;

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

class Child extends Parent<Integer> {
    @Override
    public void setData(Integer data) {
        System.out.println("Child setData: " + data);
        super.setData(data);
    }

    @Override
    public Integer getData() {
        System.out.println("Child getData");
        return super.getData();
    }
}

public class Main {
    public static void main(String[] args) {
        Parent<Integer> parent = new Child(); // 多态！
        parent.setData(10); // 应该调用 Child 的 setData 方法吗？
        Integer data = parent.getData(); // 应该调用 Child 的 getData 方法吗？
    }
}

按照我们的预期，parent.setData(10) 应该调用 Child 的 setData 方法，因为 parent 实际上指向的是 Child 对象，这就是多态的威力。

但是，由于泛型擦除，Parent 类的 setData 方法实际上变成了：

public void setData(Object data) {
    this.data = (T) data; // 注意这里的强制类型转换
}

而 Child 类重写的 setData 方法是：

public void setData(Integer data) {
    System.out.println("Child setData: " + data);
    super.setData(data);
}

现在问题来了，Parent 的 setData(Object data) 方法和 Child 的 setData(Integer data) 方法，它们的方法签名不一样！

也就是说，Child 类实际上并没有重写 Parent 类的 setData 方法！ 😱

这可怎么办？多态性被破坏了，代码的行为变得不可预测了！

别担心，Java 还有一个秘密武器：桥接方法 (Bridge Method)。

为了解决这个问题，编译器会自动在 Child 类中生成一个 桥接方法：

// 编译器自动生成的桥接方法
public void setData(Object data) {
    setData((Integer) data); // 调用 Child 真正的 setData 方法
}

这个桥接方法的作用是：

接收一个 Object 类型的参数 (为了满足 Parent 类的 setData 方法的要求)。
将 Object 类型的参数强制转换成 Integer 类型。
调用 Child 类真正的 setData(Integer data) 方法。

这样，就保证了多态性的正确性。 👏

用表格总结一下：

特性	作用
桥接方法	解决泛型擦除导致的多态性问题
生成时机	编译器在编译时自动生成
方法签名	桥接方法的方法签名与父类方法一致 (参数类型为擦除后的类型，例如 `Object`)
方法体	桥接方法的方法体通常是将参数强制转换成子类需要的类型，然后调用子类真正的方法

第三幕：深入挖掘，揭秘桥接方法的“真面目”🕵️‍♀️

桥接方法到底长什么样呢？我们可以通过反射来查看一下。

import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) {
        Class<?> clazz = Child.class;
        Method[] methods = clazz.getDeclaredMethods();

        for (Method method : methods) {
            System.out.println("Method name: " + method.getName());
            System.out.println("Is bridge method: " + method.isBridge());
            System.out.println("-----------------------");
        }
    }
}

运行上面的代码，你会发现 Child 类中除了我们定义的 setData 和 getData 方法之外，还有一个 setData 方法，并且它的 isBridge() 方法返回 true。

这就是桥接方法！ 🕵️

注意： 桥接方法是编译器自动生成的，我们无法在源代码中看到它。

第四幕：泛型擦除与桥接方法的“爱恨情仇” 💔

泛型擦除和桥接方法就像一对“欢喜冤家”，它们之间既有合作，也有冲突。

泛型擦除是“罪魁祸首”。 如果没有泛型擦除，就不会有多态性问题，也就不需要桥接方法了。
桥接方法是“救世主”。 它弥补了泛型擦除带来的缺陷，保证了多态性的正确性。

它们之间的关系可以用一句话来概括：泛型擦除制造问题，桥接方法解决问题。

第五幕：泛型擦除与桥接方法的“应用场景” 🎭

理解泛型擦除和桥接方法，可以帮助我们更好地理解泛型的底层实现，避免一些潜在的陷阱。

理解泛型的局限性。 泛型擦除意味着在运行时无法获取泛型的具体类型信息。因此，一些依赖于运行时类型信息的场景，泛型就无能为力了。
避免类型转换异常。 在使用泛型时，要注意类型安全，避免强制类型转换，以免发生 ClassCastException。
理解桥接方法的作用。 理解桥接方法可以帮助我们更好地理解多态性的实现机制，避免一些潜在的错误。

终幕：泛型，一个不断进化的“魔法师” ✨

泛型是 Java 中一个非常重要的特性，它提高了代码的类型安全性和可读性。

虽然泛型擦除带来了一些问题，但 Java 通过桥接方法等机制，巧妙地解决了这些问题。

随着 Java 的不断发展，泛型也在不断进化。未来，我们期待泛型能够更加强大，更加灵活，为我们的代码带来更多的便利。

感谢各位观众的观看！希望今天的“Java 奇幻夜”能够让你对泛型擦除和桥接方法有一个更深入的理解。

下次再见！ 👋