title: Java Type 总结
date: 2022/06/24 16:44

Java 类型总结

Type及其子接口的来历：

泛型出现之前的类型：没有泛型的时候，只有原始类型。此时，所有的原始类型都通过字节码文件类Class类进行抽象。Class类的一个具体对象就代表一个指定的原始类型。

泛型出现之后的类型：泛型出现之后，扩充了数据类型。从只有原始类型扩充了参数化类型、类型变量类型、限定符类型 、泛型数组类型。

java.lang.reflect.Type 有很多的子类，接下来一个个看一下。

image.png

ParameterizedType

只有拥有泛型的类才会是这个类型

测试代码：

@Test
public void test() {
  Field field = ReflectionUtils.findField(TestParameterizedType.class, "map");
  ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
  System.out.println(Arrays.toString(parameterizedType.getActualTypeArguments()));  // [class java.lang.String, TypeVariable F]
  System.out.println(parameterizedType.getRawType());   // interface java.util.Map
  System.out.println(parameterizedType.getOwnerType()); // null
}

static class TestParameterizedType<F extends Serializable> {
  Map<String, F> map;
}

TypeVariable

参数类型，代表泛型参数

测试代码：

@Test
public void test() {
    Field field = ReflectionUtils.findField(TestParameterizedType.class, "map");
    ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();// Map
    TypeVariable<Class<?>> typeVariable = (TypeVariable<Class<?>>) parameterizedType.getActualTypeArguments()[1];
    System.out.println(typeVariable.getName()); // F
    System.out.println(Arrays.toString(typeVariable.getBounds()));   // [interface java.io.Serializable]
    System.out.println(typeVariable.getGenericDeclaration());   // class ATest$TestParameterizedType

    Method testMethod = ReflectionUtils.findMethod(TestParameterizedType.class, "testMethod", Class.class);
    ParameterizedType methodParameterType = (ParameterizedType) new MethodParameter(testMethod, 0).getNestedGenericParameterType();
    TypeVariable actualTypeArgument = (TypeVariable) methodParameterType.getActualTypeArguments()[0];
    System.out.println(actualTypeArgument.getName()); // T
    System.out.println(Arrays.toString(actualTypeArgument.getBounds()));   // [class java.lang.Object]
    System.out.println(actualTypeArgument.getGenericDeclaration());   // Method public static void ATest$TestParameterizedType.testMethod(java.lang.Class)
}

static class TestParameterizedType<F extends Serializable> {
    Map<String, F> map;

    public static <T> void testMethod(Class<T> tClass) {
    }
}

WildcardType

通配符类型

@Test
public void testWildcardType() {
    Field a = ReflectionUtils.findField(WildcardTypeCls.class, "a");
    WildcardType aType = (WildcardType) ((ParameterizedType) a.getGenericType()).getActualTypeArguments()[0];
    System.out.println(aType.getTypeName());    // ? extends java.lang.Number
    System.out.println(Arrays.toString(aType.getLowerBounds()));    // []
    System.out.println(Arrays.toString(aType.getUpperBounds()));    // [class java.lang.Number]

    Field b = ReflectionUtils.findField(WildcardTypeCls.class, "b");
    WildcardType bType = (WildcardType) ((ParameterizedType) b.getGenericType()).getActualTypeArguments()[0];
    System.out.println(bType.getTypeName());    // ? extends T
    System.out.println(Arrays.toString(bType.getLowerBounds()));    // []
    System.out.println(Arrays.toString(bType.getUpperBounds()));    // [TypeVariable T]

    Field c = ReflectionUtils.findField(WildcardTypeCls.class, "c");
    WildcardType cType = (WildcardType) ((ParameterizedType) c.getGenericType()).getActualTypeArguments()[0];
    System.out.println(cType.getTypeName());    // ? super java.lang.String
    System.out.println(Arrays.toString(cType.getLowerBounds()));    // [class java.lang.String]
    System.out.println(Arrays.toString(cType.getUpperBounds()));    // [class java.lang.Object]
}

static class WildcardTypeCls<T> {
    // 没有下边界，上边界为 Number
    private List<? extends Number> a;

    // 上边界为 T
    private List<? extends T> b;

    // 没有指定的话，上边界默认是 Object，下边界是 String
    private List<? super String> c;
}

GenericArrayType

泛型数组类型。

Generic：通用，在这里代表泛型的意思，详见泛型出现是为了解决啥问题的。

测试代码：

@Test
public void testGenericArrayType() {
    Field eArray = ReflectionUtils.findField(GenericArrayTypeCls.class, "eArray");
    System.out.println(((GenericArrayType) eArray.getGenericType()).getGenericComponentType()); // TypeVariable E

    Field eListArray = ReflectionUtils.findField(GenericArrayTypeCls.class, "eListArray");
    System.out.println(((GenericArrayType) eListArray.getGenericType()).getGenericComponentType()); // ParameterizedType List<E>  E - TypeVariable

    Field wildcardListArray = ReflectionUtils.findField(GenericArrayTypeCls.class, "wildcardListArray");
    System.out.println(((GenericArrayType) wildcardListArray.getGenericType()).getGenericComponentType()); // ParameterizedType List<?>  ? - WildcardType

    Field stringListArray = ReflectionUtils.findField(GenericArrayTypeCls.class, "stringListArray");
    System.out.println(((GenericArrayType) stringListArray.getGenericType()).getGenericComponentType());    // ParameterizedType List<String>  String - Class

    Field stringArray = ReflectionUtils.findField(GenericArrayTypeCls.class, "stringArray");
    System.out.println(stringArray.getGenericType());   // 这个不是 GenericArrayType 类型。class [Ljava.lang.String;
}

static class GenericArrayTypeCls<E> {
    E[] eArray;
    List<E>[] eListArray;
    List<?>[] wildcardListArray;
    List<String>[] stringListArray;

    // 这个不是
    String[] stringArray;
}