Java 反射之泛型

Java 反射之泛型

概述

在 Java 中，泛型是一项强盛的特性，它提供了编译时范例安全查抄机制，答应在界说类、接口和方法时利用范例参数。然而，由于 Java 的泛型存在范例擦除机制，在运行时泛型的具体范例信息通常会被擦除。不外，Java 反射机制提供了一些工具和接口，让我们在某些场景下可以或许在运行时获取泛型的干系信息。
范例

• TypeVariable：表现泛型类中声明的范例变量。如：class MyClass<T> 此中的 T 就是一个范例变量。
  
• ParamterizedType：表现参数化范例，即带有现实泛型参数的泛型范例。获取泛型范例的现实范例参数信息，如：List<String>、Map<Integer, String>。
  
• GenericeArrayType：表现元素范例是参数化范例大概范例变量的数组范例。用于获取泛型数组元素的范例信息，如：List<String>[]。
  

TypeVariable

表现泛型类中声明的范例变量。如：class MyClass<T> 此中的 T 就是一个范例变量。

• getName()：获取范例变量的名称。
  
• getBounds()：获取范例变量的上界。
  

1. class Person<K extends Comparable & Serializable, V> {
2.     K key;
3.     V value;
4. }
6. public class Test {
7.     public static void main(String[] args) throws NoSuchFieldException {
8.         Person<String, Double> person = new Person<String, Double>();
10.         // 获取变量的Field
11.         Field keyField = person.getClass().getDeclaredField("key");
12.         Field valueField = person.getClass().getDeclaredField("value");
14.         // 获取类型变量
15.         TypeVariable keyType = (TypeVariable) keyField.getGenericType();
16.         TypeVariable valueType = (TypeVariable) valueField.getGenericType();
18.         // 获取类型变量名
19.         System.out.println(keyType.getName()); // K
20.         // 获取类型变量的泛型类
21.         System.out.println(keyType.getGenericDeclaration()); // class Person
22.         System.out.println(valueType.getName()); // V
23.         System.out.println(valueType.getGenericDeclaration()); // class Person
25.         // 获取上界
26.         for (Type type : keyType.getBounds()) {
27.             System.out.println(type);
28.         }
29.         // interface java.lang.Comparable
30.         // interface java.io.Serializable
32.         for (Type type : valueType.getBounds()) {
33.             System.out.println(type);
34.         }
35.         // class java.lang.Object
36.     }
37. }

复制代码

ParameterizedType

表现参数化范例，即带有现实范例参数的泛型范例，如 List<String>、Map<Integer, String> 等。

• getRawType()：获取原始范例。
  
• getActualTypeArguments()：获取现实范例参数的数组。
  

1. class Person {
2.     Map<String, Integer> map;
3. }
5. public class Test {
6.     public static void main(String[] args) throws NoSuchFieldException {
7.         Field field = Person.class.getDeclaredField("map");
9.         // 获取泛型类型
10.         Type genericType = field.getGenericType();
11.         System.out.println(genericType); // java.util.Map<java.lang.String, java.lang.Integer>
13.         // 转参数化类型
14.         ParameterizedType pType = (ParameterizedType) genericType;
16.         // 获得原始类型
17.         Type rawType = pType.getRawType();
18.         System.out.println(rawType); // interface java.util.Map
20.         // 获取实际类型
21.         for (Type t : pType.getActualTypeArguments()) {
22.             System.out.println("泛型实际类型参数：" + t.getTypeName());
23.         }
24.         //泛型实际类型参数：java.lang.String
25.         //泛型实际类型参数：java.lang.Integer
26.     }
27. }

复制代码

GenericeArrayType

表现元素范例是参数化范例大概范例变量的数组范例，如：List<String>[]。

1. public class Test {
2.     private List<String>[] array;
4.     public static void main(String[] args) throws NoSuchFieldException {
5.         // 获取field
6.         Field field = Test.class.getDeclaredField("array");
7.         // 获取泛型类型
8.         Type genericType = field.getGenericType();
9.         // 转为泛型数组类型
10.         if (genericType instanceof GenericArrayType) {
11.             GenericArrayType genericArrayType = (GenericArrayType) genericType;
12.             // 获取数组类型
13.             Type genericComponentType = genericArrayType.getGenericComponentType();
14.             // 转为参数化类型
15.             if (genericComponentType instanceof ParameterizedType) {
16.                 ParameterizedType pType = (ParameterizedType) genericComponentType;
17.                 // 获取实际类型参数
18.                 Type[] actualTypeArguments = pType.getActualTypeArguments();
19.                 for (Type actualTypeArgument : actualTypeArguments) {
20.                     System.out.println("实际类型参数：" + actualTypeArgument.getTypeName());
21.                 }
22.             }
23.         }
24.     }
25. }
27. // 实际类型参数：java.lang.String

复制代码

方法

• getTypeParameters()：Class 类和 Method 类都提供了 getTypeParameters() 方法，用于获取类或方法中声明的范例变量。
  
• getGenericSuperClass()：Class 类的 getGenericSuperclass() 方法用于获取当前类的直接父类的泛型范例。
  
• getGenericReturnType()：Method 类的 getGenericReturnType() 方法用于获取方法返回值的泛型范例。
  

getTypeParameters()

• 在 Class 类：用于获取类大概接口的泛型的范例变量。
  
• 在 Method 类：用于获取方法的泛型的范例变量。
  

1. // 获取类的泛型信息：
2. public class Test<T, U> {
3.     public static void main(String[] args) throws NoSuchFieldException {
4.         TypeVariable<?>[] typeParameters = Test.class.getTypeParameters();
5.         for (TypeVariable<?> typeParameter : typeParameters) {
6.             System.out.println("类型变量名称：" + typeParameter.getName());
7.             Type[] bounds = typeParameter.getBounds();
8.             for (java.lang.reflect.Type type : bounds) {
9.                 System.out.println("上界：" + type.getTypeName());
10.             }
11.         }
12.     }
13. }
15. // 类型变量名称：T
16. // 上界：java.lang.Object
17. // 类型变量名称：U
18. // 上界：java.lang.Object

复制代码

1. // 获取方法的泛型信息：
2. public class Test {
4.     public <V, W> void genericMethod(V v, W w) {
6.     }
8.     public static void main(String[] args) throws NoSuchMethodException {
9.         Method method = Test.class.getMethod("genericMethod", Object.class, Object.class);
10.         TypeVariable<Method>[] typeParameters = method.getTypeParameters();
11.         for (TypeVariable<?> typeParameter : typeParameters) {
12.             System.out.println("方法的类型变量：" + typeParameter.getName());
13.             Type[] types = typeParameter.getBounds();
14.             for (Type type : types) {
15.                 System.out.println("上界：" + type.getTypeName());
16.             }
17.         }
18.     }
19. }
21. // 方法的类型变量：V
22. // 上界：java.lang.Object
23. // 方法的类型变量：W
24. // 上界：java.lang.Object

复制代码

getGenericSuperClass()

获取父类的泛型范例。

1. // 父类有泛型：
2. class MyArrayList extends ArrayList<String> {
4. }
6. public class Test {
7.     public static void main(String[] args) throws NoSuchMethodException {
8.         Type superclass = MyArrayList.class.getGenericSuperclass();
9.         if (superclass instanceof ParameterizedType) {
10.             ParameterizedType pType = (ParameterizedType) superclass;
11.             Type[] actualTypeArguments = pType.getActualTypeArguments();
12.             for (Type type : actualTypeArguments) {
13.                 System.out.println("父类实际类型参数：" + type);
14.             }
15.         }
16.     }
17. }
19. // 父类实际类型参数：class java.lang.String

复制代码

1. // 父类没有泛型：
2. class MyClass {
4. }
6. public class Test {
7.     public static void main(String[] args) throws NoSuchMethodException {
8.         Type superclass = MyClass.class.getGenericSuperclass();
9.         if (superclass instanceof Class) {
10.             Class<?> parentClass = (Class<?>) superclass;
11.             System.out.println("父类类型：" + parentClass);
12.         }
13.     }
14. }
16. // 父类类型：class java.lang.Object

复制代码

getGenericReturnType()

获取返回值的范例范例。

1. // 返回值有泛型：
2. public class Test {
3.     public List<String> getStringList() {
4.         return null;
5.     }
7.     public static void main(String[] args) throws NoSuchMethodException {
8.         Method method = Test.class.getMethod("getStringList");
9.         Type returnType = method.getGenericReturnType();
10.         if (returnType instanceof ParameterizedType) {
11.             ParameterizedType pType = (ParameterizedType) returnType;
12.             Type[] actualTypeArguments = pType.getActualTypeArguments();
13.             for (Type type : actualTypeArguments) {
14.                 System.out.println("返回值的实际类型参数：" + type.getTypeName());
15.             }
16.         }
17.     }
18. }
20. // 返回值的实际类型参数：java.lang.String

复制代码

1. // 返回值没有泛型：
2. public class Test {
3.     public int getInt() {
4.         return 0;
5.     }
7.     public static void main(String[] args) throws NoSuchMethodException {
8.         Method method = Test.class.getMethod("getInt");
9.         Type returnType = method.getGenericReturnType();
10.         if (returnType instanceof Class) {
11.             Class<?> c = (Class) returnType;
12.             System.out.println("返回值类型：" + c.getName());
13.         }
14.     }
15. }
17. // 返回值类型：int

复制代码