获取Type类型的常见方法

1. 获取原始类型（Class）

Class是Type的实现类之一，可直接通过类名或对象获取：

Class<?> stringClass = String.class;
Class<?> integerClass = Integer.class;

// 通过对象获取
String str = "hello";
Class<?> objClass = str.getClass();

2. 获取泛型类型（ParameterizedType）

对于带有泛型的类或方法，需要在运行时通过反射获取其实际类型参数：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

public class GenericTypeExample {
    public static void main(String[] args) throws NoSuchFieldException {
        // 1. 通过字段获取泛型类型
        class MyClass {
            List<String> list = new ArrayList<>();
        }
        Type listType = MyClass.class.getDeclaredField("list").getGenericType();
        if (listType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) listType;
            Type[] typeArgs = pType.getActualTypeArguments();
            System.out.println("泛型参数类型：" + typeArgs[0]); // 输出: class java.lang.String
        }

        // 2. 通过匿名内部类获取泛型类型
        List<Integer> intList = new ArrayList<Integer>() {}; // 注意这里使用匿名内部类
        Type superType = intList.getClass().getGenericSuperclass();
        if (superType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) superType;
            System.out.println("匿名内部类的泛型参数：" + pType.getActualTypeArguments()[0]); // 输出: class java.lang.Integer
        }
    }
}

3. 获取类型变量（TypeVariable）

对于泛型类或方法中的类型变量（如T），可以通过反射获取：

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.List;

public class TypeVariableExample {
    public static <T> void genericMethod(List<T> list) {}

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = TypeVariableExample.class.getMethod("genericMethod", List.class);
        Type[] params = method.getGenericParameterTypes();
        
        if (params[0] instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) params[0];
            Type[] typeArgs = pType.getActualTypeArguments();
            
            if (typeArgs[0] instanceof TypeVariable) {
                TypeVariable<?> typeVar = (TypeVariable<?>) typeArgs[0];
                System.out.println("类型变量名称：" + typeVar.getName()); // 输出: T
                System.out.println("类型变量的上界：" + typeVar.getBounds()[0]); // 输出: class java.lang.Object
            }
        }
    }
}

4. 获取数组类型（GenericArrayType）

对于泛型数组，可以获取其组件类型：

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Type;
import java.util.List;

public class ArrayTypeExample {
    public static void main(String[] args) throws NoSuchFieldException {
        class MyClass {
            List<String>[] array;
        }
        Type fieldType = MyClass.class.getDeclaredField("array").getGenericType();
        
        if (fieldType instanceof GenericArrayType) {
            GenericArrayType arrayType = (GenericArrayType) fieldType;
            Type componentType = arrayType.getGenericComponentType();
            System.out.println("数组组件类型：" + componentType); // 输出: java.util.List<java.lang.String>
        }
    }
}

5. 获取通配符类型（WildcardType）

对于使用通配符（如? extends Number）的泛型类型：

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.WildcardType;
import java.util.List;

public class WildcardTypeExample {
    public static void main(String[] args) throws NoSuchFieldException {
        class MyClass {
            List<? extends Number> list;
        }
        Type fieldType = MyClass.class.getDeclaredField("list").getGenericType();
        
        if (fieldType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) fieldType;
            Type[] typeArgs = pType.getActualTypeArguments();
            
            if (typeArgs[0] instanceof WildcardType) {
                WildcardType wildcardType = (WildcardType) typeArgs[0];
                System.out.println("上界：" + wildcardType.getUpperBounds()[0]); // 输出: class java.lang.Number
                System.out.println("下界：" + (wildcardType.getLowerBounds().length > 0 ? 
                                           wildcardType.getLowerBounds()[0] : "无"));
            }
        }
    }
}

总结

• Class：表示具体的类或接口类型。
• ParameterizedType：表示参数化类型（如List<String>）。
• TypeVariable：表示类型变量（如泛型中的T）。
• GenericArrayType：表示泛型数组（如List<String>[]）。
• WildcardType：表示通配符类型（如? extends Number）。