Java 泛型采用类型擦除机制，运行时泛型信息被移除以保证兼容性。这导致无法使用基本类型作为泛型参数、不能实例化泛型类型或创建泛型数组、不能用 instanceof 判断泛型类型以及静态成员不能引用泛型类类型参数。编译器通过桥接方法解决方法重写兼容性问题。理解擦除原理有助于避免常见错误并写出安全代码。
Java 泛型的设计有个独特之处：类型信息只存在于编译期，运行时会被彻底擦除。这种'擦除'机制让很多开发者困惑：为什么 和在运行时是同一个类型？为什么不能用基本类型作为泛型参数？为什么创建泛型数组会报错？今天我们就从泛型擦除的底层原理讲起，彻底搞懂这些问题，看清泛型的'真面目'。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
List<String>List<Integer>泛型是 Java 5 引入的特性，但为了兼容之前的版本（Java 5 之前没有泛型），Java 采用了**类型擦除（Type Erasure）**的实现方式：编译时检查泛型类型合法性，运行时擦除所有泛型信息。也就是说，泛型只在编译期起作用，运行时 JVM 根本不知道泛型参数的存在。
泛型擦除的本质是将泛型类型替换为其原始类型（Raw Type），具体规则：
<T extends Number>），则擦除为该上限类型；<T>），则擦除为Object；<T extends A & B>），则擦除为第一个上限类型。示例：泛型类擦除前后对比
// 泛型类定义
public class Box<T extends Number> {
private T value;
public T getValue() { return value; }
public void setValue(T value) { this.value = value; }
}
// 擦除后（编译为字节码的实际类型）
public class Box {
// 去掉泛型参数<T extends Number>
private Number value; // T 被替换为上限 Number
public Number getValue() { return value; } // 返回值类型变为 Number
public void setValue(Number value) { this.value = value; } // 参数类型变为 Number
}
Java 5 之前的代码没有泛型，大量使用原始类型（如List而非List<String>）。为了让这些旧代码能与新的泛型代码无缝交互，Java 必须保证：泛型类在运行时的类型与非泛型类兼容。例如，Java 5 之前的List和 Java 5 之后的List<String>，在运行时必须是同一个类型（都是List.class），否则旧代码无法操作新的泛型集合。擦除机制正是为了实现这种兼容性。
擦除会移除泛型信息，那运行时的类型安全怎么保证？答案是：编译器在擦除的同时，自动添加类型检查和转型代码。
// 泛型代码
List<String> list = new ArrayList<>();
list.add("hello");
String str = list.get(0);
// 擦除后（编译器生成的实际代码）
List list = new ArrayList();
list.add("hello"); // 编译时检查：确保添加的是 String
String str = (String) list.get(0); // 自动添加转型代码
add("hello")是否符合List<String>的类型约束，若添加123会直接报错；(String)转型代码，保证取出的元素类型正确（若因特殊操作导致类型不匹配，仍会抛ClassCastException）。泛型擦除原理图解
擦除机制虽然保证了兼容性，但也给泛型带来了诸多限制。理解这些限制的根源，才能避免开发中的'坑'。
你可能注意到，List<int>会编译报错，必须用List<Integer>。这是因为：泛型擦除后会替换为 Object 或上限类型，而基本类型（int、double 等）不是 Object 的子类，无法转型。
List<int>，擦除后应为List<Object>，但int是基本类型，不能直接存储在Object数组中（需要装箱为 Integer）；反例（编译报错）：
// 错误：基本类型不能作为泛型参数
List<int> intList = new ArrayList<>(); // 编译报错
Map<double, boolean> map = new HashMap<>(); // 编译报错
// 正确：使用包装类
List<Integer> intList = new ArrayList<>();
Map<Double, Boolean> map = new HashMap<>();
new T()）无法在泛型类中直接创建泛型参数的实例（new T()），因为擦除后T会被替换为Object或上限类型，编译器无法确定具体类型。
反例（编译报错）：
public class Box<T> {
public Box() {
// 错误：不能实例化泛型类型 T
T value = new T(); // 编译报错
}
}
原因：擦除后T变为Object，new T()会被视为new Object()，这显然不符合预期（我们想要的是T的实例，而非 Object）。
解决方案：通过反射创建实例（需传入 Class 对象）：
public class Box<T> {
private T value;
// 传入 Class 对象，通过反射创建实例
public Box(Class<T> clazz) throws InstantiationException, IllegalAccessException {
value = clazz.newInstance(); // 合法
}
}
// 使用
Box<String> box = new Box<>(String.class); // 需显式传入 Class 对象
new T[]）无法直接创建泛型数组（new T[10]），因为擦除后数组的实际类型是Object[]，会导致类型安全问题。
反例（编译报错）：
public class ArrayBox<T> {
public void createArray() {
// 错误：不能创建泛型数组
T[] array = new T[10]; // 编译报错
}
}
原因：擦除后T[]变为Object[]，若将其赋值给具体类型的数组（如String[]），再存入其他类型元素，会在运行时引发隐藏的ClassCastException：
// 假设允许创建 T[]，擦除后实际为 Object[]
Object[] array = new Object[10];
String[] strArray = (String[]) array; // 编译不报错（危险！）
strArray[0] = 123; // 运行时抛 ArrayStoreException（int 不能存到 String 数组）
编译器为了避免这种隐藏的风险，直接禁止创建泛型数组。
解决方案：
ArrayList<T>代替泛型数组（推荐，无需处理类型问题）；Object[]数组，使用时手动转型（需谨慎，可能引发异常）：public class ArrayBox<T> {
private Object[] array;
public ArrayBox(int size) {
array = new Object[size]; // 创建 Object 数组
}
public T get(int index) {
return (T) array[index]; // 取出时转型
}
public void set(int index, T value) {
array[index] = value; // 存入时自动装箱
}
}
instanceof判断泛型类型instanceof是运行时类型检查，而泛型类型在运行时已被擦除，因此无法用instanceof判断泛型参数。
反例（编译报错）：
List<String> list = new ArrayList<>();
// 错误：不能用 instanceof 判断泛型类型
if (list instanceof List<String>) {
// ...
}
原因：运行时List<String>和List<Integer>都是List类型，instanceof无法区分。
替代方案：若需判断集合元素类型，可通过泛型类的Class参数（需手动传入）：
public class GenericChecker<T> {
private Class<T> clazz;
public GenericChecker(Class<T> clazz) {
this.clazz = clazz;
}
// 检查集合元素是否为 T 类型
public boolean check(List<?> list) {
for (Object obj : list) {
if (!clazz.isInstance(obj)) {
return false;
}
}
return true;
}
}
// 使用
GenericChecker<String> checker = new GenericChecker<>(String.class);
List<Object> list = Arrays.asList("a", "b", 123);
System.out.println(checker.check(list)); // false（包含 Integer）
泛型类的类型参数是实例级别的（每个实例可以有不同的类型参数），而静态成员是类级别的（所有实例共享），因此静态变量 / 方法不能使用泛型类的类型参数。
反例（编译报错）：
原因：擦除后泛型类的类型参数消失，静态成员无法关联到具体的类型参数（不同实例的T可能不同）。
注意：静态泛型方法是允许的，因为它有自己的泛型参数（独立于类的类型参数）：
public class StaticBox<T> {
// 正确：静态泛型方法有自己的类型参数 S
public static <S> S create(S obj) {
return obj;
}
}
泛型限制图解
擦除会导致一个隐藏问题：泛型类的方法重写可能在擦除后变得不兼容。为了解决这个问题，编译器会自动生成桥接方法（Bridge Method）。
假设有泛型父类和子类：
// 泛型父类
class Parent<T> {
public void setValue(T value) {}
}
// 子类指定泛型参数为 String
class Child extends Parent<String> {
@Override
public void setValue(String value) {} // 重写父类方法
}
擦除后，父类的setValue(T)变为setValue(Object)，而子类的setValue(String)与父类的setValue(Object)参数类型不同（不满足重写条件）。这会导致多态失效：
Parent<String> parent = new Child();
parent.setValue("hello"); // 期望调用子类的 setValue(String)
为了保证多态正确，编译器会为子类自动生成桥接方法：
class Child extends Parent {
// 编译器生成的桥接方法（重写父类的 setValue(Object)）
public void setValue(Object value) {
setValue((String) value); // 调用子类实际的 setValue(String)
}
// 子类自己的方法
public void setValue(String value) {}
}
桥接方法的作用是：在擦除后仍保持方法重写的多态性，确保父类引用调用方法时能正确指向子类实现。
通过反射可以看到编译器生成的桥接方法：
import java.lang.reflect.Method;
public class BridgeDemo {
public static void main(String[] args) {
for (Method method : Child.class.getMethods()) {
if (method.getName().equals("setValue")) {
System.out.println("方法：" + method);
System.out.println("是否桥接方法：" + method.isBridge());
}
}
}
}
// 输出结果：
// 方法：public void Child.setValue(java.lang.String)
// 是否桥接方法：false
// 方法：public void Child.setValue(java.lang.Object)
// 是否桥接方法：true
可以清晰看到，子类有两个setValue方法，其中setValue(Object)是桥接方法（isBridge()返回 true）。
泛型擦除是 Java 为了兼容性做出的妥协，它既带来了便利（兼容旧代码），也带来了限制（类型信息丢失）。核心要点：
new T()）和创建泛型数组（new T[]）；instanceof判断泛型类型（运行时无类型信息）；理解泛型擦除，不仅能避免开发中的常见错误，更能让你明白 Java 泛型的设计哲学 —— 在兼容性和类型安全之间寻找平衡。虽然泛型有诸多限制，但合理使用（结合通配符、反射等）仍能写出灵活且安全的代码。记住：泛型是编译期的'语法糖'，运行时它的'真面目'是原始类型。