解释一下类型擦除？

八股文_Java基础面试题 0 3

参考回答**

类型擦除（Type Erasure）是 Java 中泛型实现的核心机制。类型擦除的目的是为了让泛型在编译时提供类型检查的安全性，但在运行时仍然兼容之前的非泛型代码（即 Java 1.5 之前的代码）。具体来说，泛型信息只存在于编译阶段，在编译后会被擦除，运行时不保留泛型的类型信息。

定义：
- 类型擦除是指 Java 编译器在编译泛型代码时，将泛型的类型参数用其 限定类型（上限） 或 Object 替代，从而在字节码中移除泛型相关信息。
关键点：
- 泛型信息只在编译时有效，运行时泛型信息会被擦除。
- 泛型的类型参数被替换为它的限定类型（类型上限），如果没有指定类型上限，则替换为 Object。
类型擦除的示例：
- 编译后的泛型类与普通类没有区别，泛型参数被擦除。

示例代码：

public class GenericExample<T> {
    private T data;

    public T getData() {
        return data;
    }

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

在编译后（类型擦除后），变成：

public class GenericExample {
    private Object data;

    public Object getData() {
        return data;
    }

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

详细讲解与拓展

为什么需要类型擦除？

向后兼容性：
- Java 在 1.5 之前没有泛型，为了让新加入泛型功能的代码能够与旧代码兼容，设计了类型擦除机制。
- 编译后的泛型代码与 Java 1.4 的非泛型代码能共存。
运行时性能优化：
- 泛型类型在运行时不存在，可以减少运行时的内存消耗和性能开销。

类型擦除的过程

泛型类型替换：

编译器会将泛型参数替换为它的上限（类型边界）。

如果没有指定上限，则替换为 Object。

示例：

public class Box<T> {
   private T item;

   public T getItem() {
       return item;
   }

   public void setItem(T item) {
       this.item = item;
   }
}

编译后：

public class Box {
   private Object item;

   public Object getItem() {
       return item;
   }

   public void setItem(Object item) {
       this.item = item;
   }
}

类型边界替换：

如果泛型指定了类型边界，则替换为指定的类型边界。

示例：

public class Box<T extends Number> {
   private T item;

   public T getItem() {
       return item;
   }

   public void setItem(T item) {
       this.item = item;
   }
}

编译后：

public class Box {
   private Number item;

   public Number getItem() {
       return item;
   }

   public void setItem(Number item) {
       this.item = item;
   }
}

桥方法（Bridge Method）：

类型擦除可能导致方法签名的冲突，为了解决这种冲突，Java 编译器会生成桥方法。

示例：

class Parent<T> {
   public T getValue() {
       return null;
   }
}

class Child extends Parent<String> {
   @Override
   public String getValue() {
       return "Hello";
   }
}

编译后：

class Parent {
   public Object getValue() {
       return null;
   }
}

class Child extends Parent {
   @Override
   public String getValue() {
       return "Hello";
   }

   // 编译器生成的桥方法
   @Override
   public Object getValue() {
       return getValue(); // 调用子类的 getValue()
   }
}

类型擦除的局限性和问题

运行时类型信息丢失：

由于泛型信息在运行时被擦除，无法通过反射获取泛型的具体类型。
示例：

“`java
List<String> list = new ArrayList<>();
System.out.println(list.getClass()); // 输出：class java.util.ArrayList
“`

无法区分 List<String> 和 List<Integer>，运行时它们的类型相同。

无法直接创建泛型数组：

由于泛型在运行时被擦除，无法直接创建泛型数组。
示例：

“`java
List<String>[] array = new List<String>[10]; // 编译报错
“`
解决办法：使用 Object 数组来间接实现：

“`java
List<String>[] array = (List<String>[]) new List<?>[10];
“`

类型擦除导致的类型安全问题：

类型擦除会导致某些场景下的潜在类型安全问题。
示例：

“`java
List list = new ArrayList<Integer>();
list.add("Hello"); // 编译不会报错
Integer value = (Integer) list.get(0); // 运行时抛出 ClassCastException
“`

泛型类型不能用于静态变量：

静态变量在类加载时共享，而泛型信息在运行时被擦除，导致静态变量无法使用泛型。
示例：

“`java
class GenericClass<T> {
private static T staticVar; // 编译报错
}
“`

拓展：解决泛型局限性的方式

引入泛型类型参数：

使用类的构造参数或方法参数来保留泛型信息。
示例：

“`java
public class GenericHolder<T> {
private Class<T> type;

<pre><code> public GenericHolder(Class<T> type) {
this.type = type;
}

public T newInstance() throws InstantiationException, IllegalAccessException {
return type.newInstance();
}
</code></pre>

}

“`

使用 TypeToken（Guava 提供）：

通过 TypeToken 来间接获取泛型的运行时类型。
示例：

“`java
TypeToken<List<String>> typeToken = new TypeToken<List<String>>() {};
System.out.println(typeToken.getType()); // 输出：java.util.List<java.lang.String>
“`

Java 泛型的改进：

Scala、Kotlin 等语言通过运行时保留泛型类型解决了 Java 类型擦除的问题。

总结

特点	解释
目的	提供编译时的类型检查，同时保持与非泛型代码的兼容性。
过程	泛型类型被替换为其上限（类型边界），如果无上限则替换为 `Object`。
局限性	泛型信息在运行时丢失，无法获取具体的泛型类型；泛型数组和泛型静态变量受限制。
解决办法	使用 `Class` 对象、`TypeToken` 或其他框架工具保留泛型类型信息。

参考回答**

详细讲解与拓展

为什么需要类型擦除？

类型擦除的过程

类型擦除的局限性和问题

拓展：解决泛型局限性的方式

总结

发表评论 取消回复

发表评论取消回复