Java 泛型的类型擦除和使用限制详解

悠悠 2024-03-31 18:06 83阅读 0赞

**目录**

1、泛型类型擦除详解

（1）泛型类型的擦除

（2）泛型方法中的类型擦除

（3）桥接方法对类型擦除的影响

（4）非具体化类型和堆污染问题

2、泛型的使用限制

（1）不能用基本类型去实例化泛型类型

（2）不能创建泛型的实例

（3）不能声明类型为泛型的静态字段

（4）类型转换或 instanceof 不能和泛型类型一起使用

（5）不能创建参数化类型的数组

（6）不能创建、捕获或抛出泛型类型的对象

（7）不能重载泛型类型擦除后具备相同原始类型的方法

--------------------

什么是类型擦除？Java 泛型的实现是在编译层，编译后生成的字节码中不包含泛型中的类型信息。所以使用泛型时，加上的类型参数，会在编译器编译的时候去掉，这个过程称为类型擦除。

### 1、泛型中的类型擦除详解 ###

Java 引入泛型是为了在编译时提供更严格的类型检查，并支持泛型编程。为了实现泛型，Java 编译器会进行下述操作：

1.  将泛型类型中的所有类型参数都替换为它们的边界类型或 Object (如果类型参数是无界的)。因此，生成的字节码只会包含普通的类、接口和方法。
2.  必要时会插入类型强制转换以保证类型安全。
3.  生成桥接方法用来保证泛型类型中的多态性。

类型擦除不会为参数化类型创建新的类；因此，使用泛型不会产生运行时开销。

#### （1）泛型类中的类型的擦除 ####

在类型擦除过程中，Java 编译器会擦除所有的类型参数，如果类型参数是有界的，则用它的边界类型替换每个类型参数，如果类型参数是无界的，则用 Object 替换每个类型参数。

下边是单链表(List)中的节点泛型类：

public class Node<T> {
    
        private T data;
        private Node<T> next;
    
        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    
        public T getData() { return data; }
        // ...
    }

因为类型参数 T 是无界的，所以 Java 编译器会将它替换为 Object：// 类型擦除

public class Node {
    
        private Object data;
        private Node next;
    
        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
    
        public Object getData() { return data; }
        // ...
    }

在下面的例子中，泛型 Node 类使用了一个有界的类型参数：

public class Node<T extends Comparable<T>> {
    
        private T data;
        private Node<T> next;
    
        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    
        public T getData() { return data; }
        // ...
    }

所以，Java 编译器会用边界类替换原来的类型参数 T， 本例中为 Comparable 类：

public class Node {
    
        private Comparable data;
        private Node next;
    
        public Node(Comparable data, Node next) {
            this.data = data;
            this.next = next;
        }
    
        public Comparable getData() { return data; }
        // ...
    }

#### （2）泛型方法中的类型擦除 ####

Java 编译器还会擦除泛型方法参数中的类型参数。比如下面的泛型方法：

// 计算数组中elem的出现次数
    public static <T> int count(T[] anArray, T elem) {
        int cnt = 0;
        for (T e : anArray)
            if (e.equals(elem))
                ++cnt;
            return cnt;
    }

因为 T 是无界的，所以 Java 编译器会将它替换为 Object：// 跟类中的类型擦除一样

public static int count(Object[] anArray, Object elem) {
        int cnt = 0;
        for (Object e : anArray)
            if (e.equals(elem))
                ++cnt;
            return cnt;
    }

所以，如果定义了以下类：

class Shape { /* ... */ }
    class Circle extends Shape { /* ... */ }
    class Rectangle extends Shape { /* ... */ }

那么就可以写一个泛型方法来画出不同的形状：

public static <T extends Shape> void draw(T shape) { /* ... */ }

Java 编译器会将 T 替换为 Shape：

public static void draw(Shape shape) { /* ... */ }

#### （3）桥接方法对类型擦除的影响 ####

有时侯，类型擦除会导致一些意外的情况。比如，给定以下两个类：

public class Node<T> {
    
        public T data;
    
        public Node(T data) { this.data = data; }
    
        public void setData(T data) {
            System.out.println("Node.setData");
            this.data = data;
        }
    }
    
    public class MyNode extends Node<Integer> {
        public MyNode(Integer data) { super(data); }
    
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
    }

如果使用下边的代码进行操作，就会抛出类型转换异常：

MyNode mn = new MyNode(5);
    Node n = mn;            // 原始类型 - 编译器会抛出未经检查的警告
    n.setData("Hello");     // 抛出ClassCastException异常
    Integer x = mn.data;

这是因为在类型被擦除之后，这段代码实际变成了如下形式：

MyNode mn = new MyNode(5);
    Node n = mn;            // 原始类型 - 编译器会抛出未经检查的警告
                            // 注意: 该代码可以被以下代码替换：Node n = (Node)mn;
                            // 不过，编译器不会进行强制转换，因为不是必需的。
    n.setData("Hello");     // 导致抛出ClassCastException异常
    Integer x = (Integer)mn.data;

接下来，解释一下为什么会在 n.setData("Hello") 的时候抛出 ClassCastException 异常。

当编译器在编译一个继承参数化类或实现参数化接口的类或接口时，它需要创建一个合成方法，该方法称为桥接方法，它是类型擦除过程的一部分。通常情况下都不需要去关注桥接方法，但如果在堆栈跟踪中出现了一个桥接方法，很多人可能会感到迷惑。

在类型擦除之后，Node 和 MyNode 类会变成如下形式：

public class Node {
    
        public Object data;
    
        public Node(Object data) { this.data = data; }
    
        public void setData(Object data) {
            System.out.println("Node.setData");
            this.data = data;
        }
    }
    
    public class MyNode extends Node {
    
        public MyNode(Integer data) { super(data); }
    
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
    }

不知道你有没有注意到，当类型擦除后，会导致方法签名不匹配，其中 Node.setData(T) 方法变成了 Node.setData(Object)，而 MyNode.setData(Integer) 方法并不会覆盖 Node.setData(Object) 方法。// 参数类型不一致，无法重写

所以，为了解决这个问题，在类型擦除后还能保留泛型类型的多态性，Java 编译器生成了一个桥接方法，用来确保子类型可以按预期目标进行工作。// 桥接方法是类型擦除的一部分

对于 MyNode 类，编译器为 setData() 方法生成了以下桥接方法:

class MyNode extends Node {
    
        // 由编译器生成的桥方法
        public void setData(Object data) {
            setData((Integer) data);
        }
    
        public void setData(Integer data) {
            System.out.println("MyNode.setData");
            super.setData(data);
        }
        // ...
    }

上边示例中，桥接方法 MyNode.setData(object) 委托给了 MyNode.setData(Integer) 方法。所以，当 n.setData("Hello") 时，调用的是 MyNode.setData(Object) 方法，而它的委托方法是 MyNode.setData(Integer) ，所以会抛出 ClassCastException 异常，因为 "Hello" 字符串类型并不能转换为 Integer 类型。

#### （4）非具体化类型和堆污染问题 ####

**1）非具体化类型**

具体化的类型是指类型信息在运行时完全可用的类型，它包括基本类型、非泛型类型、原始类型和未绑定通配符的类型。

非具体化类型是指在编译时通过类型擦除可以删除信息的类型。该类型在运行时不具备所有可用的信息。非具体化类型的例子如 List<String> 和 List<Number>；JVM 不能在运行时具体区分这些类型（区分 List 中存的具体是 String 还是 Number）。

**2）堆污染和未检查警告**

当参数化类型的变量引用不属于该参数化类型的对象时，就会发生堆污染。如果程序在编译时产生了未检查的警告，就会可能发生这种情况。当程序在编译时，编译器无法验证参数化类型操作的正确性(例如，一些强制转换或方法调用的操作)，就会生成未检查警告。所以，混合基本数据类型和参数化类型或执行未经检查的强制转换时，就可能会发生堆污染。// 堆污染就是把多种类型混合在一起，比如本来该存放 Integer 类型的数据，结果存放了 String 类型的数据

正常情况下，当所有代码同时编译时，编译器会发出未经检查的警告，提醒注意潜在的堆污染。但如果分别编译代码的各个部分，那么就很难检测到堆污染的潜在风险。所以要防止发生堆污染，就确保所有代码在编译时都没有警告。

**3）参数可变的方法在使用非具体化参数时存在的潜在漏洞**

包含可变参数的泛型方法可能会存在堆污染。比如下边的 ArrayBuilder 类：// 主要原因在于 List<T> 中这个 T 的类型无法保证统一

public class ArrayBuilder {
    
      public static <T> void addToList (List<T> listArg, T... elements) {
        for (T x : elements) {
          listArg.add(x);
        }
      }
    
      public static void faultyMethod(List<String>... l) {
        Object[] objectArray = l;     // 有效的
        objectArray[0] = Arrays.asList(42); // 存储 Integer 类型的数据
        String s = l[0].get(0);       // 获取 String 类型的数据，会抛出 ClassCastException 异常
      }
    
    }

在编译器遇到可变参数的方法时，它会将可变参数转换为一个数组。但是，Java 并不允许创建参数化类型的数组，所以在 ArrayBuilder.addToList 方中，编译器会将可变参数 T… elements 转换为 T\[\] elements 数组，同时由于类型擦除，编译器又会将 T\[\] elements 数组转换为 Object\[\] elements 数组，这期间，就可能会存在堆污染问题。

比如，下边代码将可变参数 l 赋值给 Object 数组 objectArray：

Object[] objectArray = l;

在上边代码中，凡是跟可变参数 l 类型匹配的值都可以赋值给 Object\[\] objectArray，同时也可以赋值给可变参数 l。此时，编译器并不会在赋值语句上生成未检查警告，因为警告信息在将可变参数 List<String>... l 转换为 List\[\] l 数组时就已经生成了（String 类型被擦除）。因为 List\[\] 是 Object\[\] 数组的子类型，所以，如果将任意类型的 List 对象赋值给 objectArray 数组中任意元素，编译器也不会发出警告或错误，如下所示:

objectArray[0] = Arrays.asList(42);

但是，如果此时用如下代码调用 ArrayBuilder.faultyMethod 方法：

ArrayBuilder.faultyMethod(Arrays.asList("Hello!"), Arrays.asList("World!"));

在运行的时候，JVM 就会在以下代码中抛出 ClassCastException 异常：

// ClassCastException thrown here
    String s = l[0].get(0);

原因就在于，存储在变量 l 中的第一个数组元素的对象类型为 List<Integer>，但这条代码却期望获得一个类型为 List<String> 的对象。

**4）如何压制方法的警告信息**

如果声明了一个具有参数化类型参数的可变参数方法，并且可以确保方法体不会因为对参数的不当处理而抛出 ClassCastException 或其他类似的异常，那么就可以在方法声明中添加以下注解来阻止编译器生成警告：

@SafeVarargs

@SafeVarargs 注解是方法契约文档的一部分；该注解断言方法的实现不会不恰当地处理可变参数。

同时，也可以通过在方法声明中添加以下内容来压制此类警告，不过，要注意的是这种方式并不会压制从调用方法位置生成的警告：

@SuppressWarnings({"unchecked", "varargs"})

### 2、泛型的使用限制 ###

为了有效地使用 Java 泛型，必须考虑以下限制：

#### （1）不能用基本类型去实例化泛型类型 ####

不能用基本类型去实例化泛型类型。例如，以下参数化类型：

class Pair<K, V> {
    
        private K key;
        private V value;
    
        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }
    
        // ...
    }

当创建 Pair 对象时，不能用基本类型去替换类型参数 K 或 V：

Pair<int, char> p = new Pair<>(8, 'a');  // 编译错误

只能用非基本类型来代替类型参数 K 和 V：

Pair<Integer, Character> p = new Pair<>(8, 'a');

上边代码中，Java 编译器会自动进行装箱，把 8 装箱为 Integer.valueOf(8)，把 'a' 装箱为 Character('a')：

Pair<Integer, Character> p = new Pair<>(Integer.valueOf(8), new Character('a'));

#### （2）不能创建泛型的实例 ####

不能创建类型参数的实例。例如，下面的代码会导致编译时错误：

public static <E> void append(List<E> list) {
        E elem = new E();  // 编译错误
        list.add(elem);
    }

作为一种变通方法，可以通过反射创建一个类型参数的对象：

public static <E> void append(List<E> list, Class<E> cls) throws Exception {
        E elem = cls.newInstance();   // OK
        list.add(elem);
    }

可以像下面这样调用 append 方法：

List<String> ls = new ArrayList<>();
    append(ls, String.class);

#### （3）不能声明类型为泛型的静态字段 ####

类的静态字段是类级别的变量，由类的所有非静态对象共享。因此，不允许声明类型为泛型的静态字段。例如下面的类：

public class MobileDevice<T> {
        private static T os;
    
        // ...
    }

**原因：**因为泛型类中的泛型的实例化是在定义对象的时候指定的，而静态变量和静态方法不需要使用对象来调用，对象都没有创建，所以不能确定这个泛型参数是何种类型，因此编译的时候会报错。如果允许类型为泛型的静态字段，那么下面的代码将会产生混淆：

MobileDevice<Smartphone> phone = new MobileDevice<>();
    MobileDevice<Pager> pager = new MobileDevice<>();
    MobileDevice<TabletPC> pc = new MobileDevice<>();

因为静态字段 os 是由 phone（电话）、pager（寻呼机）和 pc 共享的，所以并不能确定实际的 os 类型是什么，它不能同时是智能手机、寻呼机和平板电脑。因此，不允许声明类型为泛型的静态字段。

#### （4）类型转换或 instanceof 不能和泛型类型一起使用 ####

因为 Java 编译器会擦除泛型代码中的所有类型参数，所以无法在运行时验证泛型类型的参数化类型：

public static <E> void rtti(List<E> list) {
        if (list instanceof ArrayList<Integer>) {  // 编译错误
            // ...
        }
    }

如果传递给 rtti() 方法的参数化类型集是：

S = { ArrayList<Integer>, ArrayList<String>, LinkedList<Character>, ... }

以为 Java 运行时不会跟踪类型参数，所以它不能区分 ArrayList<Integer> 和 ArrayList<String>。但是，可以使用一个无界通配符来验证列表是否是一个 ArrayList：

public static void rtti(List<?> list) {
        if (list instanceof ArrayList<?>) {  // OK; instanceof需要一个可具体化的类型
            // ...
        }
    }

另外，也不能强制转换参数化类型，除非该类型是由无界通配符进行参数化的。例如：

List<Integer> li = new ArrayList<>();
    List<Number>  ln = (List<Number>) li;  // 编译错误

不过，在某些情况下，编译器知道类型的形参总是有效的，会允许进行强制转换。例如：

List<String> l1 = ...;
    ArrayList<String> l2 = (ArrayList<String>)l1;  // OK

#### （5）不能创建参数化类型的数组 ####

不能创建参数化类型的数组。例如，以下代码不能通过编译：// List<Integer>

List<Integer>[] arrayOfLists = new List<Integer>[2];  // 编译错误

**原因：**编译器使用类型擦除，参数类型被替换为Object，用户可以向数组中添加任何类型对象，因此下边红色部分不能限定死类型的。

*  List<Object>\[\] stringLists=new List<String>\[1\]; 这样是不对等的
 *  List<Object>\[\] stringLists=new List\[1\]; // 这样是对等的

下面的代码演示了在数组中插入不同类型时会发生什么:

Object[] strings = new String[2];
    strings[0] = "hi";   // OK
    strings[1] = 100;    // 抛出 ArrayStoreException 异常

如果对一个泛型 List 做同样的事情，也会发生同样的问题：

Object[] stringLists = new List<String>[2];  // 编译器错误，但假设它是允许的
    stringLists[0] = new ArrayList<String>();   // OK
    stringLists[1] = new ArrayList<Integer>();  // 抛出 ArrayStoreException 异常,
                                                // 但是运行时不能检测到它。

所以如果允许创建参数化列表的数组，那么前面的代码将无法抛出 ArrayStoreException 异常。

#### （6）不能创建、捕获或抛出泛型类型的对象 ####

泛型类不能直接或间接地扩展 Throwable 类。例如，以下类将不会通过编译：

// 间接继承 Throwable 
    class MathException<T> extends Exception { /* ... */ }    // 编译错误
    
    // 直接继承 Throwable 
    class QueueFullException<T> extends Throwable { /* ... */ // 编译错误

方法不能捕获泛型类型的实例：

public static <T extends Exception, J> void execute(List<J> jobs) {
        try {
            for (J job : jobs)
                // ...
        } catch (T e) {   // 编译错误
            // ...
        }
    }

但是，你可以在 throws 子句中使用泛型：// T 是 Exception 的子类型

class Parser<T extends Exception> {
        public void parse(File file) throws T {     // OK
            // ...
        }
    }

#### （7）不能重载泛型类型擦除后具备相同原始类型的方法 ####

在类型擦除后，一个类可能会有两个相同签名的重载方法。如下所示：

public class Example {
        public void print(Set<String> strSet) { }
        public void print(Set<Integer> intSet) { }
    }