• 反射机制(Reflection)

    前言

    为什么要学习反射？

    反射可以动态创建对象以及获取对应的对象属性 方法，从而让代码更灵活不必写死，好多框架必不可少的使用了反射机制，同时反射机制也符合OCP（开闭原则）即在不修改源码的情况下，进行操作  看上边估计你可能印象不怎么大下边我举个栗子你就能感受到灵活的好处了。

    反射可以做什么？

    已知反射机制的特点后我们可以用反射机制来做个“状态机”，即根据时间来进行状态流转

    1. 可以用Redis zset延时队列 {key:value存当前类的包名类名和要执行的方法名} 后续到时间通过反射在调用执行~ 
    2. 定时任务每5秒按照时间分值取一次最近五分钟要操作的数据集
    3. 取出之后按照多线程加反射机制进行执行~因为考虑到反射机制创建对象比较慢，所以执行的时候可以开启多线程执行最近五分钟的任务执行完毕从队列删除此任务以免重复执行。

    以上只是简单的介绍了下反射机制可以做什么，需要了解详细的可以和博主私聊讨论哦~ 

    快速入门

    一个需求引出反射

    1、根据配置文件re.properties指定信息，创建Cat对象并调用方法hi

    1. classfullpath=com.hspedy.Cat
    2. method=hi
    1. package com.shb.reflection.question;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.IOException;
    5. import java.lang.reflect.InvocationTargetException;
    6. import java.lang.reflect.Method;
    7. import java.util.Properties;
    8.  
    9. /**
    10. * 反射问题引入
    11. */
    12. public class ReflectionQuestion {
    13.     
    14.     public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    15.         //根据配置文件re.properties指定信息，创建Cat对象并调用方法hi
    16.         
    17.         //传统方式 new 对象  -》调用其方法
    18.         /* Cat cat = new Cat();
    19.         cat.hi();*/
    20.         
    21.         //文件流方式 Properties
    22.         //1、取出配置文件值
    23.         Properties properties = new Properties();
    24.         properties.load(new FileInputStream("/Users/ext.songhaibo/IdeaProjects/Reflection/src/main/resources/re.properties"));
    25.         String classfullpath = properties.get("classfullpath").toString();
    26.         String methodName = properties.get("method").toString();
    27.         System.out.println("classfullpath = " + classfullpath);
    28.         System.out.println("methodName = " + methodName);
    29.         //2、创建对象 传统的方法已经不行了
    30.         // new classfullpath();
    31.         
    32.         //反射模式符合开闭原则 OCP，即在不修改源码的情况下，进行操作
    33.         
    34.         //3、传统模式下解决不了就用反射机制
    35.         //(1)加载class类 返回Class对象
    36.         Class<?> cls = Class.forName(classfullpath);
    37.         //(2)通过 cls 得到加载类  com.shb.Cat的对象实例
    38.         Object o = cls.newInstance();
    39.         System.out.println(o.getClass());
    40.         //(3)通过 cls 得到加载的类的com.shb.Cat类的methodName"hi"的对象
    41.         //即：在反射中，可以把方法视为对象（万物皆对象）
    42.         Method method = cls.getMethod(methodName);
    43.         //通过method来调用方法，即通过方法对象来调用方法
    44.         method.invoke(o);//传统方式 对象.方法   反射机制 方法.invoke(对象)
    45.         
    46.     }
    47. }

    反射原理图

    • Java Reflection

    1.反射机制允程序在执行期借助于ReflectionAPI取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到

    2.加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为反射

    • Java反射机制可以完成
      1. 在运行时判断任意一个对象所属的类
      2. 在运行时构造任意一个类的对象
      3. 在运行时得到任意一个类所具有的成员变量和方法
      4. 在运行时调用任意一个对象的成员变量和方法
      5. 生成动态代理
    • 反射相关的主要类：

    1. java.lang.Class：代表一个类，Class对象表示某个类加载后在堆中的对象
    2.  
    3. java.lang.reflect.Method：代表类的方法
    4.  
    5. java.lang.reflect.Field：代表类的成员变量
    6.  
    7. java.lang.reflect.Constructor：代表类的构造方法
    8.  
    9. 这些类在java.lang.reflect ：提供用于获取关于类和对象的反射信息的类和接口

    • 反射的优点和缺点

    优点：可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就是失去底层支撑。

    缺点：使用反射基本是解释执行，对执行速度有影响。

    例子：Reflection02.java

    1. public class Reflection02 {
    2.  
    3.     public static void main(String[] args) throws Exception {
    4.         m1();
    5.         m2();
    6.     }
    7.  
    8.     //普通方法调用hi
    9.     public static void m1() {
    10.  
    11.         Cat cat = new Cat();
    12.         long start = System.currentTimeMillis();
    13.         for (int i = 0; i < 900000000; i++) {
    14.             cat.hi();
    15.         }
    16.         long end = System.currentTimeMillis();
    17.         System.out.println("普通方法调用hi 耗时 " + (end - start));
    18.  
    19.     }
    20.  
    21.     //反射机制调用hi
    22.     public static void m2() throws Exception {
    23.         //(1)加载class类 返回Class对象
    24.         Class<?> cls = Class.forName("com.shb.Cat");
    25.         Object o = cls.newInstance();
    26.         long start = System.currentTimeMillis();
    27.         Method method = cls.getMethod("hi");
    28.         for (int i = 0; i < 900000000; i++) {
    29.             method.invoke(o);//传统方式 对象.方法   反射机制 方法.invoke(对象)
    30.         }
    31.         long end = System.currentTimeMillis();
    32.         System.out.println("反射机制调用hi 耗时 " + (end - start));
    33.  
    34.     }
    • 反射调用优化-关闭访问检查
      1. Method和Field、Constructor对象都有setAccessible()方法
      2. setAccessible作用是启动和禁用访问安全检查的开关
      3. 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查

    Class类

    • 基本介绍：
    1. Class也是类，因此也继承Object类
    2. Class类对象不是new出来的，而是系统创建的
    3. 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
    4. 每个类的实例都会记得自己是由哪个Class实例所生成
    5. 通过Class可以完整地得到一个类的完整结构，通过一系列API
    6. Class对象是存放在堆的
    7. 类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据
    • Class常用api示例
    1. /**
    2.  * Class常用api示例
    3.  */
    4. public class ClassApi {
    5.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
    6.         String classAllPath = "com.shb.Car";
    7.         //1、获取Car类对象
    8.         Class<?> cls = Class.forName(classAllPath);
    9.         //2、输出cls
    10.         System.out.println(cls);  //是哪个类型 cls
    11.         System.out.println(cls.getClass());  //运行类型
    12.         //3、获取包名
    13.         System.out.println(cls.getPackage().getName());
    14.         //4、获取全类名
    15.         System.out.println(cls.getName());
    16.         //5、生成对象实例
    17.         Object o = cls.newInstance();
    18.         Car car = (Car) o;
    19.         System.out.println(car);
    20.         //6、通过反射获取属性 不能获取私有属性
    21.         Field brand = cls.getField("brand");
    22.         System.out.println(brand.get(car));
    23.         //7、通过反射给属性设置值
    24.         brand.set(car, "奥迪");
    25.         System.out.println(brand.get(car));
    26.         //8、得到所有的属性 只能得到公共的
    27.         Field[] fields = cls.getFields();
    28.         for (Field field : fields) {
    29.             System.out.println(field.toString());
    30.         }
    31.         //9、得到所有的属性包括私有的 getDeclaredFields
    32.         for (Field declaredField : cls.getDeclaredFields()) {
    33.             System.out.println(declaredField.toString());
    34.         }
    35.  
    36.     }
    • 获取Class对象的六种方式
    1. 1. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName（）获取。
    2.   ○ 应用场景：多用于配置文件，读取类全路径，加载类。
    3.   ○ 阶段：代码阶段/编译阶段  Class.forName()
    4. 2. 前提：若已知具体的类，通过类的class获取，该方式 最为安全可靠，程序性能最高实例：Class cls=Cat.class;
    5.   ○ 应用场景：多用于参数传递，比如通过反射得到对应构造器对象。
    6.   ○ 阶段：加载阶段 类.class
    7. 3. 前提：已知某个类的实例，调用改实例的getClass()方法获取Class对象，实例：Class class= 对象.getClass()；
    8.   ○ 应用场景：通过创建好的对象，获取Class对象。
    9.   ○ 阶段：运行阶段 对象.getClass()
    10. 4. 其他方式 类加载器 得到Class对象
    11.   ○ ClassLoader cl=对象.getClass().getClassLoader();
    12.   ○ Class clazz4=cl.loadClass("类的全类名");
    13. 5. 基本数据类型得到Class对象
    14.   ○ Class cls= 基本数据类型.class
    15.   ○ 阶段：加载阶段 类.class
    16. 6. 基本数据类型对应的包装类，可以通过.type得到Class类对象
    17.   ○ Class cls=包装类.TYPE
    18.   ○ 阶段：加载阶段 类.class
    • 哪些类型有Class对象，如下类型有Class对象
    1. 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
    2. interface接口
    3. 数组
    4. enum枚举
    5. annotation注解
    6. 基本数据类型
    7. void

    类加载

    • 基本说明

    ClassLoad.java com.shb.classload

    反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

    1. 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
    2. 动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性
    3. 举例说明
    • 类加载时机
    1. 当创建对象时（new）
    2. 当子类被加载时
    3. 调用类中的静态成员时
    4. 通过反射

    Class.froName("com.shb.Cat");

    • 类加载过程图

    • 类加载各阶段完成任务

    • 加载阶段

    • 连接阶段-验证

    • 连接阶段-准备

    • 连接阶段-解析

    • Initialization（初始化）
    1. 到初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行<clinit>()方法的过程。
    2. <clinit>()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
    3. 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕[debug源码]

    通过反射获取类的结构信息

    com.shb.reflection ReflectionUtils

    • 第一组：java.lang.Class类
    1. getName：获取全类名
    2. getSimpleName：获取简单类名
    3. getFields：获取所有public修饰的属性，包含本类以及父类的
    4. getDeclaredFields：获取本类中所有属性
    5. getMethods：获取所有public修饰的方法，包含本类以及父类的
    6. getDeclaredMethods：获取本类中所有方法
    7. getConstructors：获取所有public修饰的构造器，包含本类的
    8. getDeclaredConstructors：获取本类中所有构造器
    9. getPackage：以Package形式返回 包信息
    10. getSuperClass：以Class形式返回父类信息
    11. getInterfaces：以Class[]形式返回接口信息
    12. getAnnotations：以Annotation[]形式返回注解信息
    • 第二组：java.lang.reflect.Field类
    1. getModifiers：以int形式返回修饰符（有对应的枚举）
    2. getType：以Class形式返回类型
    3. getName：返回属性名
    • 第三组：java.lang.reflect.Method类
    1. getModifiers：以int形式返回修饰符
    2. getReturnType：以Class形式获取 返回类型
    3. getName：返回方法名
    4. getParameterTypes：以Class[]返回参数类型数组
    • 第四组：java.lang.reflect.Constructor类
    1. getModifiers：以int形式返回修饰符
    2. getName：返回构造器名（全类名）
    3. getParameterTypes：以Class[]返回参数类型数组
    1. package com.shb.reflection;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.lang.annotation.Annotation;
    6. import java.lang.reflect.Constructor;
    7. import java.lang.reflect.Field;
    8. import java.lang.reflect.Method;
    9.  
    10. /**
    11.  * 通过反射获取类的结构信息 API
    12.  */
    13. public class ReflectionUtils {
    14.     public static void main(String[] args) {
    15.  
    16.     }
    17.  
    18.     @Test
    19. //    第一组：java.lang.Class类
    20.     public void api_01() throws ClassNotFoundException {
    21.         //得到Class对象
    22.         Class<?> personClass = Class.forName("com.shb.reflection.Person");
    23.         //        1. getName：获取全类名
    24.         System.out.println(personClass.getName());
    25.         //        2. getSimpleName：获取简单类名
    26.         System.out.println(personClass.getSimpleName());
    27.         //        3. getFields：获取所有public修饰的属性，包含本类以及父类的
    28.         for (Field field : personClass.getFields()) {
    29.             System.out.println(field.getName());
    30.         }
    31.         //        4. getDeclaredFields：获取本类中所有属性
    32.         for (Field declaredField : personClass.getDeclaredFields()) {
    33.             System.out.println(declaredField.getName());
    34.         }
    35.         //        5. getMethods：获取所有public修饰的方法，包含本类以及父类的
    36.         for (Method method : personClass.getMethods()) {
    37.             System.out.println(method.getName());
    38.         }
    39.         //        6. getDeclaredMethods：获取本类中所有方法
    40.         for (Method declaredMethod : personClass.getDeclaredMethods()) {
    41.             System.out.println(declaredMethod.getName());
    42.         }
    43.         //        7. getConstructors：获取所有public修饰的构造器，包含本类的
    44.         for (Constructor<?> constructor : personClass.getConstructors()) {
    45.             System.out.println(constructor.getName());
    46.         }
    47.         //        8. getDeclaredConstructors：获取本类中所有构造器
    48.         for (Constructor<?> declaredConstructor : personClass.getDeclaredConstructors()) {
    49.             System.out.println(declaredConstructor.getName());
    50.         }
    51.         //        9. getPackage：以Package形式返回 包信息
    52.         System.out.println(personClass.getPackage());
    53.         //        10. getSuperClass：以Class形式返回父类信息
    54.         System.out.println(personClass.getSuperclass());
    55.         //        11. getInterfaces：以Class[]形式返回接口信息
    56.         for (Class<?> anInterface : personClass.getInterfaces()) {
    57.             System.out.println(anInterface.getName());
    58.         }
    59.         //        12. getAnnotations：以Annotation[]形式返回注解信息
    60.         for (Annotation annotation : personClass.getAnnotations()) {
    61.             System.out.println(annotation);
    62.         }
    63.  
    64.     }
    65.  
    66.     @Test
    67. //    第二组：java.lang.reflect.Field类
    68.     public void api_02() throws ClassNotFoundException {
    69.         //得到Class对象
    70.         Class<?> personClass = Class.forName("com.shb.reflection.Person");
    71.         for (Field declaredField : personClass.getDeclaredFields()) {
    72.             //        1. getModifiers：以int形式返回修饰符（有对应的枚举）
    73.             System.out.println(declaredField.getModifiers());
    74.             //        2. getType：以Class形式返回类型
    75.             System.out.println(declaredField.getType());
    76.             //        3. getName：返回属性名
    77.             System.out.println(declaredField.getName());
    78.         }
    79.     }
    80.  
    81.     @Test
    82. //    第三组：java.lang.reflect.Method类
    83.     public void api_03() throws ClassNotFoundException {
    84.         //得到Class对象
    85.         Class<?> personClass = Class.forName("com.shb.reflection.Person");
    86.         //        6. getDeclaredMethods：获取本类中所有方法
    87.         for (Method declaredMethod : personClass.getDeclaredMethods()) {
    88.             //        1. getModifiers：以int形式返回修饰符
    89.             System.out.println(declaredMethod.getModifiers());
    90.             //        2. getReturnType：以Class形式获取 返回类型
    91.             System.out.println(declaredMethod.getReturnType());
    92.             //        3. getName：返回方法名
    93.             System.out.println(declaredMethod.getName());
    94.             //        4. getParameterTypes：以Class[]返回参数类型数组
    95.             for (Class<?> parameterType : declaredMethod.getParameterTypes()) {
    96.                 System.out.println(parameterType.getName());
    97.             }
    98.         }
    99.     }
    100.  
    101.     @Test
    102. //    第四组：java.lang.reflect.Constructor类
    103.     public void api_04() throws ClassNotFoundException {
    104.         //得到Class对象
    105.         Class<?> personClass = Class.forName("com.shb.reflection.Person");
    106.         //        8. getDeclaredConstructors：获取本类中所有构造器
    107.         for (Constructor<?> declaredConstructor : personClass.getDeclaredConstructors()) {
    108.             //        1. getModifiers：以int形式返回修饰符
    109.             System.out.println(declaredConstructor.getModifiers());
    110.             //        2. getName：返回构造器名（全类名）
    111.             System.out.println(declaredConstructor.getName());
    112.             //        3. getParameterTypes：以Class[]返回参数类型数组
    113.             for (Class<?> parameterType : declaredConstructor.getParameterTypes()) {
    114.                 System.out.println(parameterType.getName());
    115.             }
    116.         }
    117.     }
    118. }
    119.  
    120. @Deprecated
    121. class Person implements iA, iB {
    122.     public Person() {
    123.  
    124.     }
    125.  
    126.     public Person(String name, int age, String job, double sar) {
    127.         this.name = name;
    128.         this.age = age;
    129.         this.job = job;
    130.         this.sar = sar;
    131.     }
    132.  
    133.     //属性
    134.     public String name;
    135.     protected int age;
    136.     String job;
    137.     private double sar;
    138.  
    139.     //方法
    140.     public void m1(String A, Integer B) {
    141.  
    142.     }
    143.  
    144.     private void m2() {
    145.  
    146.     }
    147.  
    148.     protected void m3() {
    149.  
    150.     }
    151.  
    152.     void m4() {
    153.  
    154.     }
    155. }
    156.  
    157. interface iA {
    158.  
    159. }
    160.  
    161. interface iB {
    162.  
    163. }

    反射爆破创建实例

    • 通过反射创建对象
    1. 方式一：调用类中的public修饰的无参构造器
    2. 方式二：调用类中的指定构造器
    3. CLass类相关方法
      1. newInstance：调用类中的无参构造器，获取对应类的对象
      2. getConstructor(Class...clazz)：根据参数列表，获取对应的public 构造器对象
      3. getDecalaredConstructor(Class...clazz)：根据参数列表，获取对应的构造器对象
    1. Constructor类相关方法
      1. setAccessible：爆破
      2. newInstance(Object..obj)：调用构造器
    1. package com.shb.reflection;
    2.  
    3. import java.lang.reflect.Constructor;
    4. import java.lang.reflect.InvocationTargetException;
    5.  
    6. /**
    7.  * ● 通过反射创建对象
    8.  * 1. 方式一：调用类中的public修饰的无参构造器
    9.  * 2. 方式二：调用类中的指定构造器
    10.  * 3. CLass类相关方法
    11.  * a. newInstance：调用类中的无参构造器，获取对应类的对象
    12.  * b. getConstructor(Class...clazz)：根据参数列表，获取对应的public 构造器对象
    13.  * c. getDecalaredConstructor(Class...clazz)：根据参数列表，获取对应的构造器对象
    14.  * 4. Constructor类相关方法
    15.  * a. setAccessible：爆破
    16.  * b. newInstance(Object..obj)：调用构造器
    17.  */
    18. public class RelectCreateInstance {
    19.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    20.         //1、获取到User对象
    21.         Class<?> cls = Class.forName("com.shb.reflection.User");
    22.         //2、通过无参构造器创建对象
    23.         Object o = cls.newInstance();
    24.         System.out.println(o);
    25.         //3、通过有参构造器创建对象
    26.         /**
    27.          *    public User(String name) {
    28.          *         this.name = name;
    29.          *     }
    30.          */
    31.         //先得到构造器，在创建实例
    32.         Constructor<?> constructor = cls.getConstructor(String.class);
    33.         Object newInstance = constructor.newInstance("宋海波");
    34.         System.out.println(newInstance);
    35.         //4、通过非public的有参构造器创建对象
    36.         Constructor<?> privateConstructor = cls.getDeclaredConstructor(int.class, String.class);
    37.         //爆破  使用反射可以访问私有的构造器
    38.         privateConstructor.setAccessible(true);
    39.         Object newInstance1 = privateConstructor.newInstance(100, "李四");
    40.         System.out.println(newInstance1);
    41.  
    42.     }
    43.  
    44. }
    45.  
    46. class User {
    47.     private int age = 1;
    48.     private String name = "小明";
    49.  
    50.     public User() {
    51.  
    52.     }
    53.  
    54.     public User(String name) {
    55.         this.name = name;
    56.     }
    57.  
    58.     private User(int age, String name) {
    59.         this.age = age;
    60.         this.name = name;
    61.     }
    62.  
    63.     public int getAge() {
    64.         return age;
    65.     }
    66.  
    67.     public void setAge(int age) {
    68.         this.age = age;
    69.     }
    70.  
    71.     public String getName() {
    72.         return name;
    73.     }
    74.  
    75.     public void setName(String name) {
    76.         this.name = name;
    77.     }
    78.  
    79.  
    80.     @Override
    81.     public String toString() {
    82.         return "User{" +
    83.                 "age=" + age +
    84.                 ", name='" + name + '\'' +
    85.                 '}';
    86.     }
    87. }
    • 通过反射访问类中的成员
    1. 根据属性名获取Field对象 Field f=clazz对象.getDeclaredField(属性名)
    2. 爆破：f.setAccessible(true);//f 是Field
    3. 访问 f.set(o,值); syso(f.get(o));
    4. 如果是静态属性，则set和get中的参数o，可以写成null
    1. package com.shb.reflection;
    2.  
    3. import java.lang.reflect.Field;
    4.  
    5. /**
    6.  * 通过反射访问类中的成员
    7.  */
    8. public class ReflectAccessProperty {
    9.     public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
    10.         //1、得到Student类对象
    11.         Class<?> cls = Class.forName("com.shb.reflection.Student");
    12.         //2、创建对象  o运行类型就是Student
    13.         Object o = cls.newInstance();
    14.         System.out.println(o);
    15.         //3、使用反射操作成员变量  name  age
    16.         Field age = cls.getField("age");
    17.         age.set(o, 88);
    18.         System.out.println(o);
    19.         System.out.println(age.get(o));
    20.         //4、使用反射操作name属性 私有的 静态的
    21.         Field name = cls.getDeclaredField("name");
    22.         //因为name是私有的无法设置值，所以对name进行爆破
    23.         name.setAccessible(true);
    24.         name.set(o, "宋海波");
    25.         //应为name是静态的，所以对象写null也是可以的
    26.         name.set(null, "宋海波");
    27.         System.out.println(o);
    28.         //静态的属性name    name.get(o)  name.get(null) 都可以的
    29.         System.out.println(name.get(o));
    30.     }
    31. }
    32.  
    33. class Student {
    34.     private static String name;
    35.     public int age;
    36.  
    37.     public Student() {
    38.     }
    39.  
    40.     @Override
    41.     public String toString() {
    42.         return "Student{" +
    43.                 "name='" + name + '\'' +
    44.                 ", age=" + age +
    45.                 '}';
    46.     }
    47. }

    通过反射访问类中的成员

    • 访问方法
    1. 根据方法名和参数列表获取Method方法对象：Method m=clazz.getDeclaredMethod(方法名，XX.class);
    2. 获取对象：Object o=clazz.newInstance();
    3. 爆破：m.setAccessible(true);
    4. 访问：Object returnValue=m.invoke(o,实参列表);
    5. 注意：如果是静态方法,则invoke的参数o,可以写成null;
    1. package com.shb.reflection;
    2.  
    3. import java.lang.reflect.InvocationTargetException;
    4. import java.lang.reflect.Method;
    5.  
    6. /**
    7.  * 通过反射访问类中的成员
    8.  * ● 访问方法
    9.  */
    10. public class ReflectAccessMethod {
    11.     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, ClassNotFoundException, InvocationTargetException {
    12.         //1、得到Boss类对应的对象
    13.         Class<?> cls = Class.forName("com.shb.reflection.Boss");
    14.         //2、创建对象
    15.         Object o = cls.newInstance();
    16.         //3、调用public hi方法
    17.         Method hi = cls.getMethod("hi", String.class);
    18.         hi.invoke(o, "晓丽");
    19.         //4、调用private static方法say()
    20.         Method say = cls.getDeclaredMethod("say", int.class, String.class, char.class);
    21.         //应为say方法是私有的所以需要爆破
    22.         say.setAccessible(true);
    23.         Object invoke = say.invoke(o, 100, "张三", '男');
    24.         System.out.println(invoke);
    25.         //因为say方法是static可以传null调用
    26.         say.invoke(null, 100, "张三", '男');
    27.  
    28.     }
    29. }
    30.  
    31.  
    32. class Boss {
    33.     private static String name;
    34.     public int age;
    35.  
    36.     public Boss() {
    37.  
    38.     }
    39.  
    40.     private static String say(int n, String s, char c) {
    41.         System.out.println(n + " " + s + " " + c);
    42.         return n + " " + s + " " + c + " 我是return";
    43.     }
    44.  
    45.     public void hi(String s) {
    46.         System.out.println("hi~ " + s);
    47.     }
    48.  
    49.     @Override
    50.     public String toString() {
    51.         return "Boss{" +
    52.                 "age=" + age +
    53.                 '}';
    54.     }
    55. }

  • 相关阅读:
    0106极限存在准则两个重要的极限-函数与极限
    831.KMP字符串
    Vue的详细教程--用Vue-cli搭建SPA项目
    设计模式之外观模式
    Node.js：pnpm - 速度快、节省磁盘空间的软件包管理器
    react组件父子传值
    容器类之QT
    第四季度净利润扭亏为盈，迪士尼的流媒体终于成功了？
    4.7 wait notify - 4.11 多把锁
    一个完整的初学者指南Django-part1
  • 原文地址：https://blog.csdn.net/qq_41453424/article/details/125410088