java泛型深入,深入理解 Java 泛型

[TOC]

深入理解 Java 泛型

概述

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

类型擦除

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

public class Test {

public static void main(String[] args) {

List strList = new ArrayList<>();

List intList = new ArrayList<>();

System.out.println(strList.getClass().getName());

System.out.println(intList.getClass().getName());

}

}

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

java.util.ArrayList

java.util.ArrayList

类型擦除也是 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 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);

}

}

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 lst = mapper.readValue("[\"hello\",\"world\"]", List.class); // 编译错误

System.out.println(lst);

}

}

泛型不是协变的

在 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

}

}

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

public class Test {

public static void main(String[] args) {

List strList = new ArrayList<>();

// 编译 Error:(14, 32) java: 不兼容的类型: java.util.List无法转换为java.util.List

List objList = strList;

}

}

数组能够协变而泛型不能协变的另一个后果是，不能实例化泛型类型的数组(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[] lsa = new List[10];

}

}

构造延迟

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

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

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

public class Test {

public void doSomething(T param) {

T copy = new T(param); // 编译错误：Error:(13, 22) java: 意外的类型，需要: 类，找到: 类型参数T

}

}

不能使用 clone 方法

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

public class Test {

public void doSomething(T param) {

T copy = (T) param.clone(); // 编译 Error:(13, 27) java: clone()在java.lang.Object中访问protected

}

}

不能创建泛型数组

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

public class Test {

public void doS() {

T[] t = new T[5];

}

}

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

public class ArrayList extends AbstractList

implements List, 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];

}

}

通配符 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(); // compile success

fruits = new ArrayList(); // compile success

fruits = new ArrayList(); // compile error

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

Fruit object = fruits.get(0); // compile success

}

}

从上面代码中可以看出来，赋值是参数化类型为 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(); // compile success

fruits = new ArrayList(); // compile error

fruits = new ArrayList(); // compile success

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

Fruit object = fruits.get(0); // compile error

}

}

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

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

总结一下就是：

extends 可用于的返回类型限定，不能用于参数类型限定。

super 可用于参数类型限定，不能用于返回类型限定。

带有 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 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);

}

}

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

Debug JavaType 信息

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;

}

注解处理器

我们可以使用注解处理器，在编译期间获取泛型真实类型，并保存到类文件中，详见 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();

}

}

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

public class Pojo {

private String str;

private List intList;

private int i;

}

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

Constant pool:

#1 = Methodref #3.#21 // java/lang/Object."":()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;

#10 = Utf8 i

#11 = Utf8 I

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

示例： Field

public class Pojo {

private List 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);

}

}

执行以后，输出：

class java.lang.Integer

示例：Class

public abstract class AbsClass {

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 {

}

public class Test {

public static void main(String[] args) throws NoSuchFieldException {

ParaClass paraClass = new ParaClass();

System.out.println(paraClass.getParameterizeType());

}

}

执行以后，输出：

class java.lang.Long

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

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

参考文献