<转>深入理解 Java 泛型：类型擦除、通配符、运行时参数类型获取

深入理解 Java 泛型

概述

泛型的本质是参数化类型，通常用于输入参数、存储类型不确定的场景。相比于直接使用 Object 的好处是：编译期强类型检查、无需进行显式类型转换。

类型擦除

Java 中的泛型是在编译器这个层次实现的，在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就称为类型擦除 type erasure。

public class Test {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        List<Integer> intList = new ArrayList<>();
        System.out.println(strList.getClass().getName());
        System.out.println(intList.getClass().getName());
    }
}
 
 
1
2
3
4
5
6
7
8

上面这一段代码，运行后输出如下，可知在运行时获取的类型信息是不带具体类型的：

java.util.ArrayList
java.util.ArrayList
 
 
1
2

类型擦除也是 Java 的泛型实现方式与 C++ 模板机制实现方式之间的重要区别。这就导致：

泛型类并没有自己独有的Class类对象，只有List.class。
运行时无法获得泛型的真实类型信息。

比如在 反序列化 Json 串至 List 字符串时，需要这么做：

public class Test {
    public static final ObjectMapper mapper = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        JavaType javaType = getCollectionType(ArrayList.class, String.class);
        List<String> lst = mapper.readValue("[\"hello\",\"world\"]", javaType);
        System.out.println(lst);
    }
    // 获取泛型的Collection Type
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12

Debug 发现 getCollectionType 方法输出的是 CollectionType 对象，里面存储了元素类型 _elementType。这就相当于把 List 的元素类型 String.class 作为参数，提供给了 Jackson 去反序列化。而下面的做法会编译失败：

public class Test {
    public static final ObjectMapper mapper = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        List<String> lst = mapper.readValue("[\"hello\",\"world\"]", List<String>.class); // 编译错误
        System.out.println(lst);
    }
}
 
 
1
2
3
4
5
6
7

泛型不是协变的

在 Java 语言中，数组是协变的，也就是说，如果 Integer 扩展了 Number，那么不仅 Integer 是 Number，而且 Integer[] 也是 Number[]，在要求 Number[] 的地方完全可以传递或者赋予 Integer[]。（更正式地说，如果 Number是 Integer 的超类型，那么 Number[] 也是 Integer[]的超类型）。您也许认为这一原理同样适用于泛型类型 —— List< Number> 是 List< Integer> 的超类型，那么可以在需要 List< Number> 的地方传递 List< Integer>。不幸的是，情况并非如此。为啥呢？这么做将破坏要提供的类型安全泛型。

对于数组来说，下面的代码会有运行时错误：

public class Test {
    public static void main(String[] args) {
        String[] strArray = new String[3];
        Object[] objArray = strArray;

        objArray[0] = 1;// 运行时错误：Exception in thread "main" java.lang.ArrayStoreException: java.lang.Integer  
    }
}
 
 
1
2
3
4
5
6
7
8

而集合这么写就会有编译错误：

public class Test {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();
        // 编译 Error:(14, 32) java: 不兼容的类型: java.util.List<java.lang.String>无法转换为java.util.List<java.lang.Object>
        List<Object> objList = strList; 
    }
}
 
 
1
2
3
4
5
6
7

数组能够协变而泛型不能协变的另一个后果是，不能实例化泛型类型的数组（new List< String>[3] 是不合法的），除非类型参数是一个未绑定的通配符（new List< ?>[3]是合法的）。具体可以运行下面的代码看看：

public class Test {
    public static void main(String[] args) {
        // 编译正常
        List<?>[] lsa2 = new List<?>[10];
        // 编译 Error:(14, 30) java: 创建泛型数组
        List<String>[] lsa = new List<String>[10];
    }
}
 
 
1
2
3
4
5
6
7
8

构造延迟

因为运行时不能区分 List< String> 和 List< Integer>（运行时都是 List），用泛型类型参数标识类型的变量的构造就成了问题。运行时缺乏类型信息，这给泛型容器类和希望创建保护性副本的泛型类提出了难题。比如：

不能使用类型参数访问构造函数

您不能使用类型参数访问构造函数，因为在编译的时候还不知道要构造什么类，因此也就不知道使用什么构造函数。使用泛型不能表达“T必须拥有一个拷贝构造函数（copy constructor）”（甚至一个无参数的构造函数）这类约束，因此不能使用泛型类型参数所表示的类的构造函数。

public class Test {
    public <T> void doSomething(T param) {
        T copy = new T(param);  // 编译错误：Error:(13, 22) java: 意外的类型，需要: 类，找到: 类型参数T
    }
}
 
 
1
2
3
4
5

不能使用 clone 方法

为什么呢？因为 clone() 在 Object 中是 protected 保护访问的，调用 clone() 必须通过将 clone() 改写为 public 公共访问的类方法来完成。但是 T 的 clone() 是否为 public 是无法确定的，因此调用其 clone 也是非法的。

public class Test {
    public <T> void doSomething(T param) {
        T copy = (T) param.clone();  // 编译 Error:(13, 27) java: clone()在java.lang.Object中访问protected
    }
}
 
 
1
2
3
4
5

不能创建泛型数组

不能实例化用类型参数表示的类型数组。编译器不知道 T 到底表示什么类型，因此不能实例化 T 数组。

public class Test {
    public <T> void doS() {
        T[] t = new T[5];
    }
}
 
 
1
2
3
4
5

那么 ArrayList 是如何存储数据的呢？请看下面的源代码，是用 Object 数组存储的，所以在获取元素时要做显示类型转换（在 elementData 方法中）：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    transient Object[] elementData; // Object 数组存储数据
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }    

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }    
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }    
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通配符 extends 和 super

在泛型不是协变中提到，在使用 List< Number> 的地方不能传递 List< Integer>，那么有没有办法能让他两兼容使用呢？答案是：有，可以使用通配符。

泛型中 ? 可以用来做通配符，单纯 ? 匹配任意类型。< ? extends T > 表示类型的上界是 T，参数化类型可能是 T 或 T 的子类：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? extends Fruit> fruits = new ArrayList<>();
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile error
        fruits.add(new Apple());    // compile error

        fruits = new ArrayList<Fruit>(); // compile success
        fruits = new ArrayList<Apple>(); // compile success
        fruits = new ArrayList<Food>(); // compile error
        fruits = new ArrayList<? extends Fruit>(); // compile error: 通配符类型无法实例化  

        Fruit object = fruits.get(0);    // compile success
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

从上面代码中可以看出来，赋值是参数化类型为 Fruit 和其子类的集合都可以成功，通配符类型无法实例化。为啥上面代码中的 add 全部编译失败了呢？因为 fruits 集合并不知道实际类型是 Fruit、Apple 还是 Food，所以无法对其赋值。

除了 extends 还有一个通配符 super，< ? super T > 表示类型的下界是 T，参数化类型可以是 T 或 T 的超类：

public class Test {
    static class Food {}
    static class Fruit extends Food {}
    static class Apple extends Fruit {}

    public static void main(String[] args) throws IOException {
        List<? super Fruit> fruits = new ArrayList<>();
        fruits.add(new Food());     // compile error
        fruits.add(new Fruit());    // compile success
        fruits.add(new Apple());    // compile success

        fruits = new ArrayList<Fruit>(); // compile success
        fruits = new ArrayList<Apple>(); // compile error
        fruits = new ArrayList<Food>(); // compile success
        fruits = new ArrayList<? super Fruit>(); // compile error: 通配符类型无法实例化      

        Fruit object = fruits.get(0); // compile error
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

看上面代码可知，super 通配符类型同样不能实例化，Fruit 和其超类的集合均可赋值。这里 add 时 Fruit 及其子类均可成功，为啥呢？因为已知 fruits 的参数化类型必定是 Fruit 或其超类 T，那么 Fruit 及其子类肯定可以赋值给 T。

归根到底，还是“子类对象可以赋值给超类引用，而反过来不行”这一规则导致 extends 和 super 通配符在 add 操作上表现如此的不同。同样地，也导致 super 限定的 fruits 中 get 到的元素不能赋值给 Fruit 引用，而 extends 则可以。

总结一下就是：
1. extends 可用于的返回类型限定，不能用于参数类型限定。
2. super 可用于参数类型限定，不能用于返回类型限定。
3. 带有 super 超类型限定的通配符可以向泛型对易用写入，带有 extends 子类型限定的通配符可以向泛型对象读取。

运行时泛型参数类型获取

虽然 Java 的泛型在编译期间有类型擦除，但是如果真的需要在运行时知道泛型参数的类型，应该如何做呢？

额外保存参数类型

在上面“类型擦除”中提到了 Jackson 反序列化泛型类型，将参数类型信息显式保存下来。

public class TestJackson {
    public static final ObjectMapper mapper = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        JavaType javaType = getCollectionType(ArrayList.class, String.class);
        List<String> lst = mapper.readValue("[\"hello\",\"world\"]", javaType);
        System.out.println(lst);
    }
    // 获取泛型的Collection Type
    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12

经过 Debug 发现，getCollectionType 返回的对象实际类型是 CollectionType：

CollectionType 和 JavaType 之间的继承关系，可以看下面的代码：

public final class CollectionType extends CollectionLikeType {
}

public class CollectionLikeType extends TypeBase {
    protected final JavaType _elementType;  
}   

public abstract class TypeBase extends JavaType implements JsonSerializable {
    protected final JavaType _superClass;
    protected final JavaType[] _superInterfaces;
    protected final TypeBindings _bindings;
}    
 
 
1
2
3
4
5
6
7
8
9
10
11
12

注解处理器

我们可以使用注解处理器，在编译期间获取泛型真实类型，并保存到类文件中，详见 Java 注解：注解处理器获取泛型真实类型。

这个方法的本质也是“额外保存参数类型”，只不过方法不同罢了。

signature 属性

Java泛型的擦除并不是对所有使用泛型的地方都会擦除的，部分地方会保留泛型信息。比如 java.lang.reflect.Field 类中有一个 signature 属性保存了泛型的参数类型信息，通过 Field 的 getGenericType 方法即可得到。当然，这种方法仅限于类中的 属性，对于方法中的局部变量无能为力。

public final class Field extends AccessibleObject implements Member {
    private transient String    signature;
    private String getGenericSignature() {return signature;}
    public Type getGenericType() {
        if (getGenericSignature() != null)
            return getGenericInfo().getGenericType();
        else
            return getType();
    }
}
 
 
1
2
3
4
5
6
7
8
9
10

运行时能够获取泛型参数类型，根源在于字节码中还是包含了这些信息的，对于下面这样一个类：

public class Pojo {
    private String str;
    private List<Integer> intList;
    private int i;
}
 
 
1
2
3
4
5

使用 javac Pojo.java 命令编译之后，使用 javap -verbose Pojo.class 命令查看其字节码信息，可以看到常量池中，紧跟 intList 属性存储的就是其 Signature。

Constant pool:
   #1 = Methodref          #3.#21         // java/lang/Object."<init>":()V
   #2 = Class              #22            // Pojo
   #3 = Class              #23            // java/lang/Object
   #4 = Utf8               str
   #5 = Utf8               Ljava/lang/String;
   #6 = Utf8               intList
   #7 = Utf8               Ljava/util/List;
   #8 = Utf8               Signature
   #9 = Utf8               Ljava/util/List<Ljava/lang/Integer;>;
  #10 = Utf8               i
  #11 = Utf8               I
 
 
1
2
3
4
5
6
7
8
9
10
11
12

Field 可以获取到泛型参数信息，类似地 Class 也是可以的。下面直接上代码看如何获取吧。

示例： Field

public class Pojo {
    private List<Integer> intList;
}
public class Test {
    public static void main(String[] args) throws NoSuchFieldException {
        Field intListField = Pojo.class.getDeclaredField("intList");
        Type genericType = intListField.getGenericType();
        Class<?> parameterType = (Class<?>) ((ParameterizedType) genericType).getActualTypeArguments()[0];
        System.out.println(parameterType);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11

执行以后，输出：

class java.lang.Integer

示例：Class

public abstract class AbsClass<T> {
    protected final Type _type;
    public AbsClass() {
        Type superClass = getClass().getGenericSuperclass();
        _type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
    }
    public Type getParameterizeType() {
        return _type;
    }
}
public class ParaClass extends AbsClass<Long> {
}
public class Test {
    public static void main(String[] args) throws NoSuchFieldException {
        ParaClass paraClass = new ParaClass();
        System.out.println(paraClass.getParameterizeType());
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

执行以后，输出：

class java.lang.Long

这里 ParaClass 继承的是 AbsClass< Long>，而非 AbsClass< T>。于是，对 ParaClass.class 调用 getGenericSuperclass()，就可以进一步获取到 T 所绑定的 Long 类型。

有木有发现，这两个示例的共同点是，都用到了 ParameterizedType.getActualTypeArguments()[0] 这一句，因为泛型的参数类型也就是存在了这里。

参考文献

1. 泛型的使用
2. Java 深度历险（五）— Java 泛型
3. Java 理论和实践：了解泛型
4. Java 字节码详解
5. Java 为什么要添加运行时获取泛型的方法