Yao

V1

2022/12/02阅读:33主题:橙心

Java泛型中的类型擦除以及Type接口

Java 泛型(generics)是 JDK1.5 中引入的一个新特性,其本质是参数化类型,解决不确定具体对象类型的问题;其所操作的数据类型被指定为一个参数(type parameter)这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。

但是在 Java 中并不是真正的泛型,实际上是“伪泛型”

类型擦除(type Erasure)

为了与之前的版本兼容,JDK1.5 中通过类型擦除来增加的泛型功能。Java 泛型只是在编译器层次上,在编译后生成的字节码中是不包含泛型中类型的信息的。
通过一个例子来证明类型擦除

public class main {

    public static void main(String[] args) {
        ArrayList<String> sList = new ArrayList<String>();
        ArrayList<Integer> iList = new ArrayList<Integer>();
        System.out.println(sList.getClass() == iList.getClass());
    }
}

上面定义了两个 ArrayList,一个是 ArrayList<String>泛型类型的,一个是 ArrayList<Integer>类型的,但是最后打印的是true,说明两个类型相同。
javap -c看一下生成的生成的字节码

可以看到在字节码中,ArrayList<String>和 ArrayList<Integer>都被编译成了 ArrayList 类型,可见编译后发生了类型擦除。

  1. 既然编译后发生了类型擦除,那么虚拟机解析、反射等场景是怎么获取到正确的类型的?

在 JDk1.5 中增加泛型的同时,JCP 组织修改了虚拟机规范,增加了SignatureLocalVariableTypeTable新属性。
javap -v查看一下字节码,在main方法中包含一段

LocalVariableTypeTable:
 Start  Length  Slot  Name   Signature
   8      31     1 sList   Ljava/util/ArrayList<Ljava/lang/String;>;
   16      23     2 iList   Ljava/util/ArrayList<Ljava/lang/Integer;>;

LocalVariableTypeTable是一个可选属性,如果存在泛型,则会出现这个属性。在Signature下包含了泛型的信息。

  1. 接下来,看这段代码
ArrayList<String> sList = new ArrayList<String>();
sList.add("111");
String s = sList.get(0);

类型擦除之后,当调用sList.get(0)是如何确保返回的值不会和 String 不匹配呢?
javap -c查看一下字节码

public class com.example.demo.test.main {
       // .....省略
  public static void main(java.lang.String[]) throws java.lang.NoSuchFieldException;
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: invokespecial #3                  // Method java/util/ArrayList."<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #4                  // String 111
      11: invokevirtual #5                  // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
      14: pop
      15: aload_1
      16: iconst_0
      17: invokevirtual #6                  // Method java/util/ArrayList.get:(I)Ljava/lang/Object;
      20: checkcast     #7                  // class java/lang/String
      23: astore_2
      24: return
}

#7处有一个checkcast指令,checkcast用于检查类型强制转换是否可以进行,也就是泛型在获取值的时候进行了强制类型转换。

  1. 再来看看下面这段代码

首先定义一个 Java 泛型类

public class GenericClass<T{

    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

再定义一个子类继承它

public class GenericClassTest extends GenericClass<Integer{

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }

    @Override
    public Integer getValue(){
        return super.getValue();
    }
}

GenericClassTest中将GenericClass的泛型定义为Integer类型,并重写了 get 和 set 方法,因为存在类型擦除,父类GenericClass的泛型被擦除了。
javap -c 查看一下GenericClass编译后的字节码

可以看到类型擦除后泛型变为了Object。那么GenericClass也就变为了

public class GenericClass {

    private Object value;

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

这样,父类GenericClass中 set 和 get 方法操作的是 Object 对象,而子类GenericClassTest 操作的是 Integer 对象,为什么还可以重写?按照正常的继承关系中,这应该是重载。
按照重载的方式试一下

可以看到设置 Object 对象出现了红波浪线,不允许这样设置,看来确实是重写,而不是重载。为什么会时重写,这不是跟 Java 多态冲突么?继续往下研究。
现在用javap -c看一下子类GenericClassTest的字节码文件

GenericClassTest中 get 和/set 方法都有两个,一个是操作 Object 对象一个是操作 Integer 对象。
操作 Integer 对象的是GenericClassTest定义的,操作 Object 对象的是由编译器生成的。
再用javap -v 查看一下字节码更详细的信息。

编译器生成的两个操作 Object 对象的方法中多了两个ACC_BRIDGEACC_SYNTHETIC标志。
这就是虚拟机解决类型擦除和多态冲突问题的方法:使用桥接方法
桥接方法方法是由编译器生成的,我们在代码中并不能直接使用,但是可以通过反射拿到桥接方法再使用。

泛型一旦编译过后,类型就被擦除了,那到了运行时,怎么获取泛型信息?这就要使用 JDK 提供的 Type 类型接口了。

Type 类型

在没有泛型之前,所有的类型都通过 Class 类进行抽象,Class 类的一个具体对象就代表了一个类型。
在 JDK1.5 增加了泛型之后,扩充了数据类型,将泛型也包含了。
JDK 在原来的基础上增加了一个Type接口,它是所有类型的父接口,它的子类有

  • Class类: 原始/基本类型,包括平时我们所有的类、枚举、数组、注解,还有 int、float 等基本类型
  • ParameterizedType接口:参数化类型,比如 List<String>
  • TypeVariable接口:类型变量,比如 List<T>中的 T 就是参数化变量
  • GenericArrayType接口: 数组类型,比如 List<String>[]、T[]
  • WildcardType接口:泛型表达式类型,比如 List< ? extends Number>

ParameterizedType

参数化类型,即带有参数的类型,也就是带有<>的类型

public interface ParameterizedType extends Type {
     Type[] getActualTypeArguments();

     Type getRawType();

     Type getOwnerType();
}
  • getActualTypeArguments(): 获取类型内部的参数化类型 比如 Map<K,V>里面的 K,V 类型。
  • getRawType(): 类的原始类型,比如 Map<K,V>中的 Map 类型。
  • getOwnerType(): 获取所有者类型(只有内部类才有所有者,比如 Map.Entry 他的所有者就是 Map),若不是内部类,此处返回 null。

实例:

public class GenericClass<T{
    private List<String> list;
    private List<T> tList;

    public static void main(String[] args) {
        Class<GenericClass> genericClassClass = GenericClass.class;
        Field[] declaredFields = genericClassClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Type genericType = declaredField.getGenericType();
            if (genericType instanceof ParameterizedType) {
                System.out.println("==========" + genericType.getTypeName() + "======ParameterizedType类型=====");
                ParameterizedType parameterizedType = (ParameterizedType) genericType;
                System.out.println("getActualTypeArguments:");
                Type[] actualTypeArguments = (parameterizedType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println("    " + actualTypeArgument);
                }
                Type rawType = (parameterizedType).getRawType();
                System.out.println("getRawType:");
                System.out.println("    " + rawType);

            }
        }
    }
}

输出

==========java.util.List<java.lang.String>======ParameterizedType类型=====
getActualTypeArguments:
    java.lang.String
getRawType:
    interface java.util.List
==========java.util.List<T>======ParameterizedType类型=====
getActualTypeArguments:
    T
getRawType:
    interface java.util.List

TypeVariable

类型变量,即泛型中的变量,例如:T、K、V 等变量,可以表示任何类;

注意: 与 ParameterizedType 的区别,TypeVariable 代表着泛型中的变量,而 ParameterizedType 则代表整个泛型。比如 List<T>中,T 是 TypeVariable 类型,List<T>是 ParameterizedType 类型

public interface TypeVariable<D extends GenericDeclarationextends TypeAnnotatedElement {

    Type[] getBounds();

    getGenericDeclaration();

    String getName();
    // JDK8新增的
    AnnotatedType[] getAnnotatedBounds();
}
  • getBounds():类型对应的上限,默认为 Object 可以有多个。比如 List< T extends Number & Serializable>中的 Number 和 Serializable
  • getGenericDeclaration(): 获取声明该类型变量实体,比如 GenericClass< T>中的 GenericClass
  • getName():获取类型变量在源码中定义的名称;

实例:

public class GenericClass<T extends Number{
    private T t;

    public static void main(String[] args) {
        Class<GenericClass> genericClassClass = GenericClass.class;
        Field[] declaredFields = genericClassClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Type genericType = declaredField.getGenericType();
            if (genericType instanceof TypeVariable) {
                System.out.println("==========" + genericType.getTypeName() + "======TypeVariable类型=====");
                TypeVariable typeVariable = (TypeVariable) genericType;
                Type[] bounds = typeVariable.getBounds();
                System.out.println("getBounds:");
                for (Type bound : bounds) {
                    System.out.println("    " + bound);
                }
                System.out.println("getGenericDeclaration:");
                System.out.println("    " + typeVariable.getGenericDeclaration());
                System.out.println("getName:");
                System.out.println("    " + typeVariable.getName());


            }
        }
    }
}

输出:

==========T======TypeVariable类型=====
getBounds:
    class java.lang.Number
getGenericDeclaration:
    class com.example.demo.test.GenericClass
getName:
    T

GenericArrayType

泛型数组类型,用来描述 ParameterizedType、TypeVariable 类型的数组;例如:List<T>[] 、T[]、List<String>[]等。

注意: GenericArrayType 是来描述与泛型相关的数组,与 String[]、int[]、float[]这种类型不同。

public interface GenericArrayType extends Type {

 Type getGenericComponentType();
}
  • getGenericComponentType():返回泛型数组中元素的 Type 类型,比如 List<String>[] 中的 List<String>

实例:

public class GenericClass<T extends Number{

    private List<String>[] lists;
    private T[] ts;

    public static void main(String[] args) {
        Class<GenericClass> genericClassClass = GenericClass.class;
        Field[] declaredFields = genericClassClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Type genericType = declaredField.getGenericType();

            if (genericType instanceof GenericArrayType) {
                GenericArrayType genericArrayType = (GenericArrayType) genericType;
                System.out.println("==========" + genericType.getTypeName() + "======GenericArrayType类型=====");
                Type genericComponentType = genericArrayType.getGenericComponentType();
                System.out.println("getGenericComponentType:");
                System.out.println("    " + genericComponentType);
            }
        }
    }
}

输出:

==========java.util.List<java.lang.String>[]======GenericArrayType类型=====
getGenericComponentType:
    java.util.List<java.lang.String>
==========T[]======GenericArrayType类型=====
getGenericComponentType:
    T

WildcardType

泛型表达式(通配符表达式)。例如:? extend Number、? super Integer。

注意: WildcardType 虽然是 Type 的子接口,但不代表一种类型,,表示的仅仅是类似 ? extends T、? super K 这样的通配符表达式。

public interface WildcardType extends Type {

 Type[] getUpperBounds();

 Type[] getLowerBounds();
}
  • getUpperBounds() 获得泛型表达式上界(上限) 获取泛型变量的上边界(extends)
  • getLowerBounds() 获得泛型表达式下界(下限) 获取泛型变量的下边界(super)

实例:

public class GenericClass<T extends Number{
    private List<? extends Number> numbers;

    private List<? super Integer> integers;

    public static void main(String[] args) {
        Class<GenericClass> genericClassClass = GenericClass.class;
        Field[] declaredFields = genericClassClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            Type genericType = declaredField.getGenericType();
            if (genericType instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) genericType;

                Type[] actualTypeArguments = (parameterizedType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    if(actualTypeArgument instanceof WildcardType){
                        System.out.println("==========" + actualTypeArgument.getTypeName() + "======WildcardType类型=====");
                        WildcardType wildcardType = (WildcardType) actualTypeArgument;
                        System.out.println("getUpperBounds:");
                        Type[] upperBounds = wildcardType.getUpperBounds();
                        for (Type upperBound : upperBounds) {
                            System.out.println("    "+ upperBound);
                        }
                        System.out.println("getLowerBounds:");
                        Type[] lowerBounds = wildcardType.getLowerBounds();
                        for (Type lowerBound : lowerBounds) {
                            System.out.println("    "+ lowerBound);
                        }

                    }
                }
            }

        }
    }
}

输出:

==========? extends java.lang.Number======WildcardType类型=====
getUpperBounds:
    class java.lang.Number
getLowerBounds:
==========? super java.lang.Integer======WildcardType类型=====
getUpperBounds:
    class java.lang.Object
getLowerBounds:
    class java.lang.Integer

分类:

后端

标签:

Java

作者介绍

Yao
V1