JavaSE-14笔记【反射机制（+2024新）】

文章目录

1.反射机制概述
2.获取Class的四种方式
3.通过反射机制实例化对象*
4.反射机制结合配置文件灵活实例化对象*
5.java.lang.reflect.Field
- 5.1反编译类中的所有字段/属性
- 5.2 通过反射机制给属性赋值*
6.java.lang.reflect.Method
- 6.1反编译类中的所有方法
- 6.2 通过反射机制调用方法*
7.java.lang.reflect.Constructor
- 7.1 反编译类的构造方法
- 7.2 通过反射机制调用构造方法*
8.通过反射模拟实现框架的一部分
9.类加载
- 9.1 获取Class的第四种方式
- 9.2 类加载器
- 9.3 双亲委派机制
10.反射与泛型
- 10.1 通过反射获取父类的泛型
- 10.2 通过反射获取接口的泛型
- 10.3 通过反射获取属性上的泛型
- 10.4 通过反射获取方法参数和返回值上的泛型
- 10.5 通过反射获取构造方法参数的泛型

1.反射机制概述

反射机制是JDK中的一套类库，这套类库可以帮助我们操作/读取class文件，反射机制可以让程序更灵活，后期学习的大量java框架底层都是基于反射机制实现的，需要能够熟练地使用反射机制中的方法。

反射机制最核心的几个类：

java.lang.Class:Class类型的实例代表硬盘上的某个class文件，或者说代表一种类型，并且需要注意的是某种类型的class文件在内存中只有一份，无论以何种方式获取到的都是同一个；
java.lang.reflect.Field:Field类型的实例代表类中的属性/字段；
java.lang.reflect.Constructor:Constructor类型的实例代表类中的构造方法；
java.lang.refelct.Method: Method类型的实例代表类中的方法。

2.获取Class的四种方式

第一种方式： Class c = Class.forName("完整的全限定类名")；
①全限定类名是带有包名的；
②如果是lang包下的，java.lang也不能省略；
③参数为字符串参数；
④如果类不存在，运行时会报异常：java.lang.ClassNotFoundException；
⑤这个方法的执行会导致类加载。

第二种方式： 通过类的引用调用：Class c = 引用.getClass();

第三种方式： 在java中任何一种类型，包括基本数据类型，都有.class属性，用这个属性可以获取对应的Class实例：Class c = 类名.class;
第四种方式： 通过类加载器获取（具体见后9.1）

示例代码：
User类：

package reflecttest;public class User {
}

package reflecttest;public class ReflectTest01 {public static void main(String[] args) throws ClassNotFoundException {//第一种方式：Class.forName("完整的全限定类名")//stringClass代表String类型，代表硬盘上的String.class文件Class stringClass = Class.forName("java.lang.String");//获取User类型Class userClass = Class.forName("reflecttest.User");//第二种方式，obj.getClass()String s = "反射机制";Class stringClass2 = s.getClass();//某种类型的字节码文件在内存中只有一份//stringClass 和 stringClass2 都代表了同一种类型：String类型System.out.println(stringClass == stringClass2); //trueUser user = new User();Class userClass2 = user.getClass();System.out.println(userClass == userClass2); //true//第三种方式：类名.classClass intClass = int.class;Class stringClass3 = String.class;Class userClass3 = User.class;System.out.println(userClass3 == userClass); //true}
}

3.通过反射机制实例化对象*

假设userClass为获取到的User类型，则可以通过userClass.newInstance()实例化User对象，其底层是通过调用User类的无参构造方法完成对象的实例化。
注意：要使用newInstance()方法的话，必须要保证对应类中存在无参构造方法，如果没有无参构造方法，则会出现异常：java.lang.InstantiationException。

此外，newInstance()方法从java9开始已过时。

修改User类：

package reflecttest;public class User {static {System.out.println("静态代码块调用了！");}public User(){System.out.println("无参构造方法调用了！");}
}

示例代码：

package reflecttest;public class ReflectTest02 {public static void main(String[] args) throws Exception {//获取User类型，会进行类加载，类中若有静态代码块会执行Class userClass = Class.forName("reflecttest.User");//通过userClass创建User实例，返回Object类型，需要向下转型//必须保证User类中有无参构造方法User user = (User)userClass.newInstance();System.out.println(user);//每次调用创建的是不同的对象实例User user2 = (User)userClass.newInstance();System.out.println(user2);System.out.println(user == user2);}
}

运行结果：
在这里插入图片描述

4.反射机制结合配置文件灵活实例化对象*

通过此方式可以做到对象的动态创建，只需要修改属性配置文件就可以完成不同对象的实例化。

classInfo.properties配置文件：

className = reflecttest.User

测试代码（User同上）：

package reflecttest;import java.util.ResourceBundle;public class ReflectTest03 {public static void main(String[] args) throws Exception {//资源绑定器ResourceBundle resourceBundle = ResourceBundle.getBundle("reflecttest.classInfo");//通过属性配置文件的key获取valueString className = resourceBundle.getString("className");//通过反射机制实例化对象Class objClass = Class.forName(className);Object o = objClass.newInstance();System.out.println(o);}
}

运行结果：
在这里插入图片描述

classInfo.properties配置文件：

className = java.util.Date

测试代码不变，运行结果：
在这里插入图片描述

5.java.lang.reflect.Field

Vip类：

package reflecttest;public class Vip {public String name;private int age;protected boolean sex;int accountId;public static String grade = "黄金Vip";public static final String dec = "描述";}

测试代码：

package reflecttest;import java.lang.reflect.Field;
import java.lang.reflect.Modifier;/*** java.lang.reflect.Field 代表的是一个类中的字段/属性*/
public class ReflectTest04 {public static void main(String[] args) throws ClassNotFoundException {//获取Vip类Class vipClass = Class.forName("reflecttest.Vip");System.out.println("获取Vip类中所有public修饰的属性/字段：");//获取Vip类中所有public修饰的属性/字段Field[] fields = vipClass.getFields();//遍历for (Field field: fields) {//获取属性名System.out.println("属性名："+field.getName());}System.out.println("===================================");System.out.println("获取Vip类中所有属性/字段，包括私有的：");//获取Vip类中所有属性/字段，包括私有的Field[] fields1 = vipClass.getDeclaredFields();//遍历for (Field field: fields1) {//获取属性名System.out.println("属性名：" + field.getName());//获取属性类型Class fieldType = field.getType();System.out.println("属性类型：" + fieldType);//通过属性类型获取其完整类名System.out.println("属性类型完整类名：" + fieldType.getName());//通过属性类型获取其简单类名System.out.println("属性类型简单类名：" + fieldType.getSimpleName());//获取属性修饰符System.out.println("属性修饰符：" + Modifier.toString(field.getModifiers()));System.out.println();}}
}

运行结果：
在这里插入图片描述

5.1反编译类中的所有字段/属性

package reflecttest;import java.lang.reflect.Field;
import java.lang.reflect.Modifier;public class ReflectTest05 {public static void main(String[] args) throws Exception {//获取Vip类
//        Class stringClass = Class.forName("reflecttest.Vip");Class stringClass = Class.forName("java.util.Date");//字符串拼接StringBuilder sb = new StringBuilder();//获取String类的修饰符sb.append(Modifier.toString(stringClass.getModifiers()));sb.append(" class ");//获取简单类名sb.append(stringClass.getSimpleName());sb.append(" extends ");//获取父类简单类名sb.append(stringClass.getSuperclass().getSimpleName());//获取当前类实现的所有接口Class[] interfaces = stringClass.getInterfaces();if(interfaces.length > 0){sb.append(" implements ");for (int i = 0; i < interfaces.length; i++) {sb.append(interfaces[i].getSimpleName());if(i != interfaces.length-1){sb.append(",");}}}sb.append(" {\n");//获取String类中的所有属性字段Field[] fields = stringClass.getDeclaredFields();for (Field field: fields) {sb.append("\t");sb.append(Modifier.toString(field.getModifiers()));sb.append(" ");sb.append(field.getType().getSimpleName());sb.append(" ");sb.append(field.getName());sb.append(";\n");}sb.append("}");System.out.println(sb);}
}

运行结果：

在这里插入图片描述

5.2 通过反射机制给属性赋值*

Customer类：

package reflecttest;public class Customer {public String name;private int age;
}

测试代码：

package reflecttest;import java.lang.reflect.Field;public class ReflectTest06 {public static void main(String[] args) throws Exception {//获取Customer类Class customerClass = Class.forName("reflecttest.Customer");//创建对象Object o = customerClass.newInstance(); //这里可以向下转型也可以不转型//获取对应的FieldField nameField = customerClass.getField("name");//修改对应的Field的值//三要素：给哪个对象 的 哪个属性 赋什么值nameField.set(o,"张三"); //第一参数是指定对象，接收的是Object类型的；第二个参数是需要赋的值//获取对应的Field的值System.out.println(nameField.get(o));//获取ageField，此时age在类中为private的，需要调用getDeclaredField方法获取；且由于私有，无法直接赋值，需要先打破封装Field ageField = customerClass.getDeclaredField("age");//调用方法打破封装ageField.setAccessible(true);//赋值ageField.set(o,23);//获取值System.out.println(ageField.get(o));}
}

运行结果：
在这里插入图片描述

6.java.lang.reflect.Method

UserService类：

package reflecttest;public class UserService {public boolean login(String name, String password){return "admin".equals(name) && "123456".equals(password);}public void logout(){System.out.println("logout...");}
}

测试代码：

package reflecttest;import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;public class ReflectTest07 {public static void main(String[] args) throws Exception {//获取UserService类Class clazz = Class.forName("reflecttest.UserService");//获取所有声明的方法Method[] methods = clazz.getDeclaredMethods();//遍历数组for (Method method: methods) {//获取方法修饰符System.out.println(Modifier.toString(method.getModifiers()));//获取方法返回值类型System.out.println(method.getReturnType().getSimpleName());//获取方法名System.out.println(method.getName());System.out.println();//获取方法的参数列表//方式一：获取参数列表类型Class[] parameterTypes = method.getParameterTypes();for (Class parameterType: parameterTypes) {System.out.println(parameterType.getSimpleName());}System.out.println();//方式二：获取参数数组Parameter[] parameters = method.getParameters();for (Parameter parameter:parameters) {//获取参数类型System.out.println(parameter.getType().getSimpleName());//获取参数名System.out.println(parameter.getName()); //arg0,arg1,arg2...}}}
}

运行结果：
在这里插入图片描述

6.1反编译类中的所有方法

package reflecttest;import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;public class ReflectTest08 {public static void main(String[] args) throws Exception {StringBuilder sb = new StringBuilder();Class clazz = Class.forName("reflecttest.UserService");//获取类的修饰符sb.append(Modifier.toString(clazz.getModifiers()));sb.append(" class ");//获取类名sb.append(clazz.getSimpleName());sb.append(" extends ");//获取父类名sb.append(clazz.getSuperclass().getSimpleName());//获取父接口名Class[] interfaces = clazz.getInterfaces();if(interfaces.length > 0){sb.append(" implements ");for (int i = 0; i < interfaces.length; i++) {sb.append(interfaces[i].getSimpleName());if(i < interfaces.length - 1){sb.append(",");}}}sb.append(" {\n");//获取所有声明的方法Method[] methods = clazz.getDeclaredMethods();for (Method method : methods) {sb.append("\t");//获取修饰符sb.append(Modifier.toString(method.getModifiers()));sb.append(" ");//获取返回值类型sb.append(method.getReturnType().getSimpleName());sb.append(" ");//获取方法名sb.append(method.getName());sb.append("(");//获取参数列表Parameter[] parameters = method.getParameters();for (int i = 0; i < parameters.length ; i++) {//获取参数类型sb.append(parameters[i].getType().getSimpleName());sb.append(" ");//获取参数名sb.append(parameters[i].getName());if(i < parameters.length - 1){sb.append(",");}}sb.append(")\n");}sb.append("}");System.out.println(sb);}
}

运行结果：
在这里插入图片描述

6.2 通过反射机制调用方法*

package reflecttest;import java.lang.reflect.Method;public class ReflectTest09 {public static void main(String[] args) throws Exception {//获取UserService类Class clazz = Class.forName("reflecttest.UserService");//使用反射机制创建对象Object userService = clazz.newInstance();//获取login方法，需要传入方法名和所有参数类型Method login = clazz.getDeclaredMethod("login", String.class, String.class);//调用一个方法需要四个要素：//调用 哪个对象 的 哪个方法，传什么参数，返回什么值Object retValue = login.invoke(userService, "admin", "123456");System.out.println(retValue);//获取logout方法，需要传入方法名和所有参数类型Method logout = clazz.getDeclaredMethod("logout");logout.invoke(userService);}
}

运行结果：
在这里插入图片描述

7.java.lang.reflect.Constructor

7.1 反编译类的构造方法

Student类：

package reflecttest;public class Student {//编号private int id;//姓名private String name;//年级private String grade;public Student() {}public Student(int id) {this.id = id;}public Student(int id, String name) {this.id = id;this.name = name;}public Student(int id, String name, String grade) {this.id = id;this.name = name;this.grade = grade;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getGrade() {return grade;}public void setGrade(String grade) {this.grade = grade;}@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", grade='" + grade + '\'' +'}';}
}

反编译代码：

package reflecttest;import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;public class ReflectTest10 {public static void main(String[] args) throws Exception{//获取Student类Class studentClass = Class.forName("reflecttest.Student");//字符串拼接StringBuilder sb = new StringBuilder();//获取类的修饰符sb.append(Modifier.toString(studentClass.getModifiers()));sb.append(" class ");//获取类名sb.append(studentClass.getSimpleName());sb.append(" extends ");//获取父类名sb.append(studentClass.getSuperclass().getSimpleName());//获取父接口名Class[] interfaces = studentClass.getInterfaces();if(interfaces.length > 0){sb.append(" implements ");for (int i = 0; i < interfaces.length; i++) {sb.append(interfaces[i].getSimpleName());if(i < interfaces.length - 1){sb.append(",");}}}sb.append(" {\n");//获取所有声明的构造方法Constructor[] constructors = studentClass.getDeclaredConstructors();for (int i = 0; i < constructors.length; i++) {sb.append("\t");//获取构造方法修饰符sb.append(Modifier.toString(constructors[i].getModifiers()));sb.append(" ");//获取构造方法名sb.append(constructors[i].getName());sb.append("(");//获取构造方法参数列表Parameter[] parameters = constructors[i].getParameters();for (int j = 0; j < parameters.length; j++) {//获取参数类型sb.append(parameters[j].getType().getSimpleName());sb.append(" ");//获取参数名（arg0,arg1,arg2...）sb.append(parameters[j].getName());if (j < parameters.length - 1){sb.append(", ");}}sb.append(")\n");}sb.append("}");System.out.println(sb);}
}

运行结果：

在这里插入图片描述

7.2 通过反射机制调用构造方法*

package reflecttest;import java.lang.reflect.Constructor;public class ReflectTest11 {public static void main(String[] args) throws Exception{//获取Student类Class studentClass = Class.forName("reflecttest.Student");//获取无参构造方法Constructor defaultCons = studentClass.getDeclaredConstructor();//通过无参构造方法创建对象Object o1 = defaultCons.newInstance();System.out.println(o1);//获取一个参数构造方法Constructor oneParaCons = studentClass.getDeclaredConstructor(int.class);Object o2 = oneParaCons.newInstance(2201);System.out.println(o2);//获取三个参数构造方法Constructor threeParaCons = studentClass.getDeclaredConstructor(int.class, String.class, String.class);Object o3 = threeParaCons.newInstance(2301, "张三", "高三");System.out.println(o3);}
}

运行结果：
在这里插入图片描述

8.通过反射模拟实现框架的一部分

UserService类：

package reflecttest;public class UserService {public boolean login(String name, String password){return "admin".equals(name) && "123456".equals(password);}public void logout(){System.out.println("logout...");}}

package reflecttest;import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ResourceBundle;/*** 使用反射模拟实现框架的一部分*/
public class ReflectTest12 {public static void main(String[] args) throws Exception{//读取配置文件ResourceBundle resourceBundle = ResourceBundle.getBundle("reflecttest.config");//获取配置信息String className = resourceBundle.getString("className");String methodName = resourceBundle.getString("methodName");String parameterType = resourceBundle.getString("parameterType");String parameterValue = resourceBundle.getString("parameterValue");//获取类并创建对象Class clazz = Class.forName(className);Constructor defaultCons = clazz.getDeclaredConstructor();Object o = defaultCons.newInstance();//将参数类型由字符串转为对应的类String[] strparameterTypes = parameterType.split(",");Class[] classparameterTypes= new Class[strparameterTypes.length];for (int i = 0 ; i < strparameterTypes.length ; i++) {classparameterTypes[i] = Class.forName(strparameterTypes[i]);}//获取方法Method method = clazz.getDeclaredMethod(methodName, classparameterTypes);String[]  strparameterValues = parameterValue.split(",");//调用方法Object retValue = method.invoke(o, strparameterValues);System.out.println(retValue);}
}

运行结果：
在这里插入图片描述

9.类加载

类加载的过程：

装载（loading）：类加载器负责将类的class文件读入内存，并创建一个java.lang.Class对象；
连接(linking)
①验证（Verify）：确保加载类的信息符合JVM规范。
②准备（Prepare）：正式为静态变量在方法区中开辟存储空间并设置默认值。
public static int k = 10; 此时：k会赋值0
public static final int f = 10; 此时： f会赋值10
③解析（Resolve）：将虚拟机常量池内的符号引用替换为直接引用（地址）的过程。
初始化（initialization）：静态变量赋值，静态代码块执行

对应图：
在这里插入图片描述

低版本的JDK中对应类加载器的名字：
启动类加载器：负责加载rt.jar,包含java的核心类，比如String；
扩展类加载器：负责加载ext/*.jar中的类，java的扩展类；
系统类加载器：负责加载classpath中的类，比如自定义类。

9.1 获取Class的第四种方式

通过类加载器获取：
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
Class clazz = classLoader.loadClass(“全限定类名”);

Class.forName和classLoader.loadClass()的区别？

Class.forName()：类加载时会进行初始化。
classLoader.loadClass()：类加载时不会进行初始化，直到第一次使用该类。

测试代码：
Animal类：

package reflecttest;public class Animal {static {System.out.println("静态代码块执行了！");}public Animal(){System.out.println("无参构造方法执行了！");}
}

package reflecttest;public class ReflectTest13 {public static void main(String[] args) throws Exception {//获取类加载器对象（获取的是系统类加载器/应用类加载器，这个类加载器负责加载classpath中的class文件）ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();//加载类，但是这个类加载过程只完成了类加载的前两步（装载和连接），第三步初始化没做//在第一次使用类的时候才会进行初始化Class loadClass = systemClassLoader.loadClass("reflecttest.Animal");}
}

运行结果：
在这里插入图片描述

package reflecttest;public class ReflectTest13 {public static void main(String[] args) throws Exception {//获取类加载器对象（获取的是系统类加载器/应用类加载器，这个类加载器负责加载classpath中的class文件）ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();//加载类，但是这个类加载过程只完成了类加载的前两步（装载和连接），第三步初始化没做//在第一次使用类的时候才会进行初始化Class loadClass = systemClassLoader.loadClass("reflecttest.Animal");System.out.println(loadClass.newInstance());}
}

运行结果：
在这里插入图片描述

package reflecttest;public class ReflectTest13 {public static void main(String[] args) throws Exception {Class aClass = Class.forName("reflecttest.Animal");}
}

运行结果：
在这里插入图片描述

9.2 类加载器

虚拟机内部提供了三种类加载器（Java9+）：

启动类加载器（BootstrapClassLoader）：加载Java最核心的类，例如String；
平台类加载器（PlatformClassLoader）：加载Java平台扩展的类库，例如解析XML的；
应用类加载器（AppClassLoader）：加载classpath中的。

同时我们还可以自定义一个类加载器（UserClassLoader）。

获取类加载器可以通过 getParent()方法一级一级获取。
在这里插入图片描述

package reflecttest;public class ReflectTest14 {public static void main(String[] args) {//通过自定义的类获取的类加载器是：应用类加载器ClassLoader classLoader1 = ReflectTest14.class.getClassLoader();System.out.println("当前应用类加载器：" + classLoader1);//第二种获取应用类加载器的方式ClassLoader classLoader2 = ClassLoader.getSystemClassLoader();System.out.println("当前应用类加载器：" + classLoader2);//第三种获取应用类加载器的方式ClassLoader classLoader3 = Thread.currentThread().getContextClassLoader();System.out.println("当前应用类加载器：" + classLoader3);//通过getParent()方法可以获取当前类加载器的“父 类加载器”//获取平台类加载器System.out.println("当前平台类加载器：" + classLoader1.getParent());//获取启动类加载器//启动类加载器负责加载的是Java的核心类库，这个类加载器的名字看不到，直接输出的话结果是nullSystem.out.println(classLoader1.getParent().getParent());}
}

运行结果：
在这里插入图片描述

9.3 双亲委派机制

某个类加载器接收到加载类的任务时，通常委托给“父类加载器”完成加载。
最“父类加载器”无法加载时，一级一级向下委托加载任务。
作用：

保护程序的安全。
防止类加载重复。

在这里插入图片描述

10.反射与泛型

10.1 通过反射获取父类的泛型

Person类：

package reflecttest;/*** 在类上定义泛型* @param <K>* @param <Y>* @param <Z>*/
public class Person<K,Y,Z> {}

Doctor类继承Person类：

package reflecttest;public class Doctor extends Person<Integer,Double,String> {
}

测试代码：

package reflecttest;import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;public class ReflectTest15 {public static void main(String[] args) {//获取类Class<Doctor> doctorClass= Doctor.class;//获取当前类的父类泛型Type genericSuperclass = doctorClass.getGenericSuperclass();//如果当前类的父类没有使用泛型，则instanceof Class为trueSystem.out.println(genericSuperclass instanceof Class);//如果当前类的父类使用了泛型，则instanceof ParameterizedType为trueSystem.out.println(genericSuperclass instanceof ParameterizedType);System.out.println("=======================");//如果父类使用了泛型if (genericSuperclass instanceof ParameterizedType) {//转换为参数化类型ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;//获取泛型数组Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//遍历数组for (Type type: actualTypeArguments) {//获取泛型的具体类型名System.out.println(type.getTypeName());}}   } 
}

运行结果：
在这里插入图片描述

10.2 通过反射获取接口的泛型

Flyable接口：

package reflecttest;public interface Flyable<K,V> {
}

Bird类：

package reflecttest;public class Bird implements Flyable<Integer, String>, Comparable<Bird>{@Overridepublic int compareTo(Bird o) {return 0;}
}

测试代码：

package reflecttest;import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;public class ReflectTest16 {public static void main(String[] args) {//获取类Class<Bird> birdClass = Bird.class;//获取当前类实现的接口上的泛型Type[] genericInterfaces = birdClass.getGenericInterfaces();//遍历for (Type type: genericInterfaces) {//如果使用了泛型if(type instanceof ParameterizedType){//转换为参数化类型ParameterizedType parameterizedType = (ParameterizedType) type;//获取泛型数组Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//遍历数组for (Type t:actualTypeArguments) {System.out.println(t.getTypeName());}}}}
}

运行结果：
在这里插入图片描述

10.3 通过反射获取属性上的泛型

Flower类：

package reflecttest;import java.util.HashMap;public class Flower {private HashMap<Integer,String> map;
}

测试代码：

package reflecttest;import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;public class ReflectTest17 {public static void main(String[] args) throws Exception {//获取类Class<Flower> flowerClass = Flower.class;//获取指定属性，注意，由于这里map是私有的，需要使用getDeclaredField方法Field mapField = flowerClass.getDeclaredField("map");//获取属性上的泛型Type mapFieldGenericType = mapField.getGenericType();//如果使用了泛型if(mapFieldGenericType instanceof ParameterizedType){//转换为参数化类型ParameterizedType fieldGenericType = (ParameterizedType) mapFieldGenericType;//获取泛型数组Type[] actualTypeArguments = fieldGenericType.getActualTypeArguments();//遍历for (Type t: actualTypeArguments) {System.out.println(t.getTypeName());}}}
}

运行结果：
在这里插入图片描述

10.4 通过反射获取方法参数和返回值上的泛型

Dog类：

package reflecttest;import java.util.List;
import java.util.Map;public class Dog {public Map<String,String> eat(List<String> list){return null;}
}

测试代码：

package reflecttest;import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;public class ReflectTest18 {public static void main(String[] args) throws Exception {//获取类Class<Dog> dogClass = Dog.class;//获取方法Method eatMethod = dogClass.getMethod("eat", List.class);//获取方法参数上的泛型Type[] genericParameterTypes = eatMethod.getGenericParameterTypes();System.out.println(eatMethod.getName() + "方法"  + "参数上的泛型：");//遍历for (Type type:genericParameterTypes) {//如果使用了泛型if(type instanceof ParameterizedType){ParameterizedType parameterizedType = (ParameterizedType) type;Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();for (Type t:actualTypeArguments) {System.out.println(t.getTypeName());}}}//获取方法返回值上的泛型Type genericReturnType = eatMethod.getGenericReturnType();System.out.println();System.out.println(eatMethod.getName() + "方法" + "返回值上的泛型：");//如果使用了泛型if(genericReturnType instanceof ParameterizedType){ParameterizedType parameterizedType = (ParameterizedType) genericReturnType;Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();for (Type t:actualTypeArguments) {System.out.println(t.getTypeName());}}}
}

运行结果：
在这里插入图片描述

10.5 通过反射获取构造方法参数的泛型

Phone类：

package reflecttest;import java.util.Map;public class Phone {public Phone(Map<Integer,String> map){}
}

测试代码：

package reflecttest;import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;public class ReflectTest19 {public static void main(String[] args) throws Exception {//获取类Class<Phone> phoneClass = Phone.class;//获取构造方法Constructor<Phone> declaredConstructor = phoneClass.getDeclaredConstructor(Map.class);//获取构造方法参数上的泛型Type[] genericParameterTypes = declaredConstructor.getGenericParameterTypes();//遍历for (Type type:genericParameterTypes) {//如果使用了泛型if(type instanceof ParameterizedType){ParameterizedType parameterizedType = (ParameterizedType) type;Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();for (Type t:actualTypeArguments) {System.out.println(t.getTypeName());}}}}
}