反射

反射：框架设计的灵魂

名词解释：
    * 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
    * 反射：将类的各个组成部分封装为其他对象，这就是反射机制        

使用反射优点：
        1. 可以在程序运行过程中，操作这些对象。
        2. 可以解耦，提高程序的可扩展性。

获取Class对象的方式

1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
      * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取
      * 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
      * 多用于对象的获取字节码的方式

三种方式获取Class对象代码

package demo14.reflect;

public class demo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1 Class.forName("全类名")
        Class aClass = Class.forName("demo14.reflect.Person");
        System.out.println(aClass);

        // 2 类名.class
        Class bClass = Person.class;
        System.out.println(bClass);

        // 3 对象.getClass()
        Person person = new Person();
        Class cClass = person.getClass();
        System.out.println(cClass);

        //检查三种方式获取的Class对象是否一致
        System.out.println(aClass == bClass);
        System.out.println(bClass == cClass);
        
    }
}

执行结果

 

# 注：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

 Class对象功能

1. 获取成员变量们
     * Field[] getFields() ：获取所有public修饰的成员变量
     * Field getField(String name)   获取指定名称的 public修饰的成员变量

     * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
     * Field getDeclaredField(String name)  
2. 获取构造方法们
     * Constructor<?>[] getConstructors()  
     * Constructor<T> getConstructor(类<?>... parameterTypes)  

     * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
     * Constructor<?>[] getDeclaredConstructors()  
3. 获取成员方法们：
     * Method[] getMethods()  
     * Method getMethod(String name, 类<?>... parameterTypes)  

     * Method[] getDeclaredMethods()  
     * Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

4. 获取全类名    
     * String getName()  

Field：成员变量
    * 操作：
       1. 设置值
          * void set(Object obj, Object value)  
       2. 获取值
          * get(Object obj) 
       3. 忽略访问权限修饰符的安全检查
          * setAccessible(true):暴力反射

Constructor:构造方法
    * 创建对象：
        * T newInstance(Object... initargs)  
        * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

Method：方法对象
     * 执行方法：
        * Object invoke(Object obj, Object... args)  
     * 获取方法名称：
        * String getName:获取方法名

Class对象获取成员变量、对成员变量值进行获取与设置代码示例

package demo14.reflect;

import java.lang.reflect.Field;

public class demo02 {
    public static void main(String[] args) throws Exception {
        /*
         * Field[] getFields() ：获取所有public修饰的成员变量
         * Field getField(String name)   获取指定名称的 public修饰的成员变量

         * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
         * Field getDeclaredField(String name)  获取指定名称的成员变量 不考虑修饰符
         */

        // 1 获取Class对象
        Class cls = Class.forName("demo14.reflect.Person");

        // 2 获取成员变量方法
        // 2.1 获取所有的public修饰的成员变量
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        // 2.2 获取指定的public修饰的成员变量
        Field a = cls.getField("a");
        System.out.println(a);
        //2.2.1获取和设置Field值
        Person person = new Person();
        Object o = a.get(person);
        System.out.println(o);
        a.set(person, "kelvin");
        System.out.println(person);

        // 2.3 获取所有的成员变量
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }

        // 2.4 获取指定的成员变量
        Field d = cls.getDeclaredField("d");
        System.out.println(d);
        //忽略访问权限修饰符的安全检查(暴力反射)
        d.setAccessible(true);
        //2.4.1获取和设置非public修饰的Field值
        Person person1=new Person();
        Object o1 = d.get(person1);
        System.out.println(o1);
        d.set(person1,"jack");
        System.out.println(person1);
    }
}

Class对象获取构造方法，并根据构造方法创建对象

package demo14.reflect;

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class demo03 {
    public static void main(String[] args) throws Exception {
        /*
         Constructor<?>[] getConstructors()
         Constructor<T> getConstructor(类<?>... parameterTypes)

         Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
         Constructor<?>[] getDeclaredConstructors()

        创建对象：
        T newInstance(Object... initargs)
        如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

         */

        Class cls = Class.forName("demo14.reflect.Person");
        // 1 获取所有public修饰的构造方法
        Constructor[] constructors = cls.getConstructors();
        System.out.println(Arrays.toString(constructors));

        // 2 获取指定的参数的构造方法
        Constructor constructor = cls.getConstructor(String.class, int.class);
        System.out.println(constructor);
        // 2.1 使用有参构造方法创建对象
        Object kelvin = constructor.newInstance("kelvin", 23);
        System.out.println(kelvin);

        // 3 获取无参构造方法
        Constructor constructor1 = cls.getConstructor();
        System.out.println(constructor1);
        // 3.1 使用无参构造方法创建对象
        // 方式一
        Object o = constructor1.newInstance();
        System.out.println(o);
        // 方式二
        Object o1 = cls.newInstance();
        System.out.println(o1);


    }
}

Class获取成员方法并执行

package demo14.reflect;

import java.lang.reflect.Method;
import java.util.Arrays;

public class demo04 {
    public static void main(String[] args) throws Exception {
        /*
          Method[] getMethods()
          Method getMethod(String name, 类<?>... parameterTypes)

          Method[] getDeclaredMethods()
          Method getDeclaredMethod(String name, 类<?>... parameterTypes)

          执行方法：
            Object invoke(Object obj, Object... args)
          获取方法名称：
            String getName:获取方法名

         */
        Class cls = Class.forName("demo14.reflect.Person");

        // 1 获取所有的public成员方法
        Method[] methods = cls.getMethods();
        System.out.println(Arrays.toString(methods));
        // 2 获取指定的public成员带参方法
        Person person = new Person();
        Method run = cls.getMethod("run", String.class);
        run.invoke(person, "kelvin");
        // 3 获取指定的public修饰无参成员方法
        Method run1 = cls.getMethod("run");
        run1.invoke(person);

        // 4 获取private修饰的成员方法
        Method eat = cls.getDeclaredMethod("eat");
        // 暴力反射
        eat.setAccessible(true);
        eat.invoke(person);
    }
}

反射应用实例

借助配置文件，配置文件可以配置类和方法。

package demo14.reflect;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class demotest {
    /*
    不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
    */
    public static void main(String[] args) throws Exception {
        Properties pro = new Properties();

        ClassLoader classLoader = demotest.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream("demo14/reflect/pro.properties");
        pro.load(resourceAsStream);

        String className = pro.getProperty("className");
        String classMethod = pro.getProperty("classMethod");

        Class cls = Class.forName(className);
        Method method = cls.getMethod(classMethod);

        Object o = cls.newInstance();
        method.invoke(o);
    }
}

配置文件

className=demo14.reflect.Student
classMethod=study

 反射图解