El uso del mecanismo de reflexión.

Una oración describe el papel del mecanismo de reflexión: en la clase actual u otro estado de ejecución de otra clase, puede obtener dinámicamente información sobre usted u otras clases, incluidos atributos, métodos, modificadores, parámetros, tipos de parámetros, etc., y puede Modifique directamente algunas propiedades y ejecute métodos.

manual

1 Primero obtenga la clase de la clase objetivo, hay tres métodos

				//方法1根据全限定名称获取到类
          Class doMath =Class.forName("com.njupt.third.DoMath");
          //方法2通过类名的方式
          Class doMath =DoMath.class;
        //方法3先获取对象，再根据对象来获取
        DoMath doMath1= new DoMath();
        Class doMath = doMath1.getClass();

2 Crear una instancia del objeto de la clase Class, dos métodos

1.通过已经过期的方法直接获取
Object o = doMath.newInstance();

Cabe señalar que la capa inferior de este método es el método de construcción sin argumentos de la clase objetivo. Si no hay un método de construcción sin argumentos, se producirá una excepción. ! !

2，通过使用构造方法
Constructor constructor = doMath.getConstructor();
        Object o = constructor.newInstance();

3 Para obtener los atributos de la clase, primero debe obtener el modificador, tipo, nombre y otra información del atributo.

				Field[] declaredFields = doMath.getDeclaredFields();
        for(Field field :declaredFields){
    
    
            System.out.print("属性名："+field.getName() +" ");
            System.out.print("属性类型："+field.getType()+" ");
            System.out.print("属性修饰符"+field.getModifiers());
            System.out.println();
        }

Se obtendrán los siguientes resultados.

属性名：num 属性类型：double 属性修饰符2
属性名：name 属性类型：class java.lang.String 属性修饰符10
属性名：age 属性类型：int 属性修饰符1

Tenga en cuenta que el modificador se expresa en binario, si es 1, es público, 2 es privado, etc.

4 Una vez obtenido el atributo, se puede modificar el valor del atributo.

Field name = doMath.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"小娜娜");
        System.out.println(name.getModifiers());

5 Para obtener el método en la clase, primero debe obtener el modificador, el valor de retorno, el nombre, los parámetros y otra información del método.

Method[] declaredMethods = doMath.getDeclaredMethods();
for(Method method : declaredMethods){
    
    
            System.out.print("方法名："+method.getName()+" ");
            System.out.print("方法修饰符："+method.getModifiers()+" ");
            System.out.print("方法返回值类型："+method.getReturnType());
            System.out.print("方法返回值类型："+ Arrays.toString(method.getParameterTypes()));
            System.out.println();
        }

方法名：main 方法修饰符：9 方法返回值类型：void方法返回值类型：[class [Ljava.lang.String;]
方法名：add 方法修饰符：2 方法返回值类型：int方法返回值类型：[int, int]
方法名：print 方法修饰符：9 方法返回值类型：void方法返回值类型：[class java.lang.String]

Tenga en cuenta que el tipo de retorno de getModifiers() es un número entero, pero representa un modificador,

PÚBLICO: 1
PRIVADO: 2
PROTEGIDO: 4
ESTÁTICO: 8
FINAL: 16
SINCRONIZADO: 32
VOLÁTIL: 64
TRANSITORIO: 128
NATIVO: 256
INTERFAZ: 512
RESUMEN: 1024
ESTRICTO: 2048

6Método de ejecución

1. Ejecución del método de instancia
Obtenga el método primero y llame al método de invocación con los parámetros. Para el método de instancia, el primer parámetro es el objeto y los parámetros posteriores son los parámetros del método.

Method add = doMath.getDeclaredMethod("add", int.class, int.class);
        add.setAccessible(true);
        add.invoke(o,3,4);

2 Ejecución de métodos estáticos (¡llame directamente al método principal de la clase!)

Method main = doMath.getDeclaredMethod("main", String[].class);
        main.invoke(null,new String[]{
    
    null});

¿Qué pasó con el mecanismo de reflexión?

mecanismo de reflexión