JAVA---反射加图解--框架的灵魂

JAVA—反射–框架的灵魂

什么是反射？

将类的各个组成部分，封装为其他的对象；如下图

通过反射获取成员变量：

getFields()：获取所有Public修饰的成员变量

//获取Person类的Class对象
Class<Person> personClass = Person.class;
Field[] fields = personClass.getFields();
for (Field field : fields){
    System.out.println(field);
}

getField(String name):获取指定名字的public修饰的成员变量，以及成员变量的值的修改

Field name = personClass.getField("a");
System.out.println(name);
//对成员变量的值进行操作
 //对成员变量操作，获取值
Person p = new Person();
Object value = name.get(p);
System.out.println(value); //输出 null
//对成员变量设置值，将p的a属性设置为“你好”
name.set(p,"你好");
System.out.println(p);

getDeclaredFields()：获取所有的成员变量

Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println(declaredField);
}

getDeclaredField(String name):获取指定的成员变量，以及设置属性的值

Field age = personClass.getDeclaredField("age");
System.out.println(age);    //输出0  默认
//在访问非public修饰的成员变量，必须先忽略权限修饰符的安全检查
age.setAccessible(true);//暴力反射，构造方法和成员方法也可以用
//获取age的值
Object ageValue = age.get(p);
System.out.println(ageValue);  //输出0 默认
age.set(p,12);
System.out.println(age.get(p));  //输出12

获取构造方法：

 //获取peson的class对象
Class personClass = Person.class;
//获取空参构造
Constructor constructor = personClass.getConstructor();
System.out.println(constructor);
//获取有参构造方法，参数传构造方法中数据类型的class文件
Constructor constructor1 = personClass.getConstructor(String.class, int.class);
System.out.println(constructor1);

用构造器创建对象

//有参构造创建对象
Object person = constructor.newInstance("张三", 12);		
//空参构造创建对象可以简化
personClass.newInstance();

获取成员方法：

获取所有public修饰的方法

 Class personClass = Person.class;
//获取成员方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
    System.out.println(method);
}

获取指定的方法并且执行方法

//获取指定的方法名（第一个参数是方法名，后面的是参数类型的字节码文件）
Method eat = personClass.getMethod("eat",String.class);
System.out.println(eat);
//创建person对象
Person person = new Person();
//执行方法，第一个参数传对象名，后面的参数就是实参
eat.invoke(person,"aa");

获取方法名：

//获取成员方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
    System.out.println(method);
    //获取方法名
    System.out.println(method.getName());
}

获取类名

Class personClass = Person.class;
System.out.println(personClass.getName());

获取Class对象的三种方式(对象上图的三个阶段)

//1.多用于配置文件，将类名定义在配置文件中，读取文件，加载类
Class.forName("全类名");  //全类名：包名+类名
//2.多用于参数的传递
类名.class      //通过类名属性class获取
//3.多用于对象获取字节码的方式
对象.getClass        //getClass方法在Object方法中定义
    
//注意：哦同一个字节码文件在一次程序运行过程中，只会背加载一次，不论通过哪一种方式获得的Class对象都是同一个

例：需求：写一个“框架类”，可以创建任意类的对象，可以执行任意方法

配置文件

className = Test.Person
methodName = eat

Person类：

public class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

main：

package Test;

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

public class ReflectTest {
    /*
    * 写一个“框架类”，可以创建任意类的对象，可以执行任意方法
    * */
    /*
    * 步骤：
    * 1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
    * 2.在程序中加载读取配置文件
    * 3.使用反射技术加载类文件进内存
    * 4.创建对象
    * 5.执行方法
    * */
    public static void main(String[] args) throws Exception {
        //1.加载配置文件
        //1.1 创建Properties对象
        Properties prop = new Properties();
        //1.2获取配置文件的路径，通过类加载器加载
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        //获取配置文件 返回的是字节流
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        //加载配置文件进内存
        prop.load(is);

        //2.获取配置文件中定义的数据
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}