Java type

Type 类型

泛型的引入使得一部分错误可以提前到编译时期发现，极大地增强了代码的健壮性。但是我们知道 java 泛型在运行的时候是会进行泛型擦除的，那我们要怎样得到在编译时期泛型的信息呢？java 为我们提供了 Type 接口，
如图 Java中的type主要有四种类型
ParameterizedType, TypeVariable, GenericArrayType, WildcardType

ParameterizedType

Type[] getActualTypeArguments();//返回 这个 Type 类型的参数的实际类型数组
Type getRawType();//返回<>前面的
Type getOwnerType();//返回的是这个 ParameterizedType 所在的类的 Type

TypeVariable

Type[] getBounds(); 得到上边界的 Type数组,如下图例子T没有边界，默认object,ID的边界是Serializable
D getGenericDeclaration(); 返回的是声明这个 Type 所在的类 的 Type
String getName(); 返回的是这个 type variable 的名称

public class BaseReflect<T, ID extends Serializable> {
private String clazz;
public BaseReflect() {
    TypeVariable[] typeParameters = getClass().getSuperclass().getTypeParameters();
    for (TypeVariable typeVariable : typeParameters) {
        System.out.println(typeVariable.getName());//获得名称，即K,V,E
        System.out.println(typeVariable.getBounds()[0]);//上限，即继承的类或者接口
    }
    //当前对象的直接超类的 Type
    Type genericSuperclass = getClass().getGenericSuperclass();

    if (genericSuperclass instanceof ParameterizedType) {
        //参数化类型
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        //返回表示此类型实际类型参数的 Type 对象的数组
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        for (Type type : actualTypeArguments) {
            System.out.println(type);
        }
        this.clazz = actualTypeArguments[0].getTypeName();
    } else {
        this.clazz = genericSuperclass.getTypeName();
    }
}

public String getClazz() {
    return clazz;
}}

GenericArrayType

简单来说就是：范型数组,组成数组的元素中有范型则实现了该接口; 它的组成元素是 ParameterizedType 或 TypeVariable 类型

WildcardType 通配符的类型

public void getData(List<? extends Number> data) {

    System.out.println("data :" + data.get(0));
}
    @Test
public void test4() throws NoSuchMethodException {

    Method method = getClass().getDeclaredMethod("getData", List.class);

    Type type[] = method.getGenericParameterTypes();

   for (Type type1 : type) {
        if (type1 instanceof ParameterizedType) {
            System.out.println(type1.getTypeName());
            ParameterizedType type2 = (ParameterizedType) type1;//第一层是一个带泛型的泛型
            System.out.println("getTypeName:"+type2.getTypeName());
            System.out.println("getRawType:"+type2.getRawType());
            System.out.println("getActualTypeArguments[0]:"+type2.getActualTypeArguments()[0]);//获取到的<>里面第一个是? extends Number
            Type type3 = type2.getActualTypeArguments()[0];//? extends Number这就是一个通配符泛型
            if (type3 instanceof WildcardType) {
                WildcardType type4 = (WildcardType) type3;
                System.out.println(type4.getUpperBounds()[0]);//获取到通配符的上边界
            }

        }
    }
}