Java中的反射机制

反射：框架设计的灵魂

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

反射的好处
1.可以在程序执行过程中，操作这些对象
2.可以降低程序的耦合性，提高程序的可扩展性

获取Class对象的三种方式

1.Class.forName(“全类名”):将字节码文件加载进内存，返回Class对象。
2.类名.class:通过类名的属性class获取
3.对象.getClass:getClass()方法在Object类中定义着

首先在cn.itcast.reflect路径下创建Person类，内有private String name;private int age;以及各种常规方法

public class ReflectDemo04 {
    public static void main(String[] args) throws Exception {
        //1.Class.forName("全类名"):
        Class cls1 = Class.forName("cn.itcast.domain.Person");
        System.out.println(cls1);
        //2.类名.class:
        Class cls2 = Person.class;
        System.out.println(cls2);
        //3.对象.getClass:
        Person person = new Person();
        Class cls3 = person.getClass();
        System.out.println(cls3);

        System.out.println(cls1==cls2);//true
        System.out.println(cls2==cls3);//true
	//比较了三个对象，不论哪种方式获取的Class对象都是同一个，所以三个相等
    }
}

Class对象的获取功能

1.获取成员变量们
Field[] getFields();
Field getField(String name);
Field[] getDeclaredFields()；
Field getDeclaredField()；

public class ReflectDemo01 {
    public static void main(String[] args) throws Exception {
        //获取person类的class对象
        Class personClass = Person.class;
        //Field getFields()//获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("----------------");
        //Field getField(String name)获取所有public修饰的指定名称的成员变量
        Field a = personClass.getField("a");
        System.out.println(a);
        //获取成员变量a的值
        Person p = new Person();
        Object o = a.get(p);
        System.out.println(o);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);
        System.out.println("------------");
        //Field[] getDeclaredFields()获取所有成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        Field d = personClass.getDeclaredField("d");
        //因为d是私有的，所以需要忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        System.out.println(d.get(p));

    }
}

2.获取构造方法们
Constuctor<?>[] getConstructors()
Constuctor[] getConstructor(类<?>… parameterTypes)
Constuctor<?>[] getDeclaredConstructors()
Constuctor[] getDeclaredConstructor(类<?>… parameterTypes)

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {
        //Class获取构造方法
        Class<Person> personClass = Person.class;
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object p = constructor.newInstance("张三", 22);//其实构造方法底层就是这样创建的
        System.out.println(p);

        System.out.println("------------");
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object p1 = constructor.newInstance("张三", 22);//其实构造方法底层就是这样创建的
        System.out.println(p1);
    }
}

3.获取成员方法们
Method[] getMethods()
Method getMethods(String name,类<?>…parameterType)
Method[] getDeclaredMethods()
Method getDeclaredMethods(String name,类<?>…parameterType)

public class ReflectDemo03 {
    public static void main(String[] args) throws Exception{
        //获取成员方法们
        Class personClass = Person.class;
        //获取指定名称的方法
        Method method = personClass.getMethod("eat");
        System.out.println(method.getName());
        Person p = new Person();
        method.invoke(p);//执行方法
        Method method2 = personClass.getMethod("eat", String.class);
        method2.invoke(p,"小明");

        //获取所有public方法对象(也包含所有的Object)，生成一个数组
        Method[] methods = personClass.getMethods();
        for (Method m:methods){
            System.out.println(m);//方法名
            System.out.println(m.getName());
        }

        //获取类名
        String className = personClass.getName();
        System.out.println(className);
    }
}

反射案例
需求：写一个框架，不改变任何代码的前提下可以帮我们创建任意类的对象，并且执行其中任意方法
实现
1.配置文件
2.反射
步骤
1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2.将程序中加载读取配置文件
3.使用反射技术来加载类文件进内存
4.创建对象
5.执行方法

在Person类中写一个要实现的方法
public void eat(){
    System.out.println("eat...");
}
首先创建一个配置文件pro.properties
className=cn.itcast.domain.Person
methodName=eat

框架类
public class ReflectTest {
    public static void main(String[] args) throws Exception {	
	/*
        前提：不能改变该类的任何代码，下面这样传统的就不合适了
         */
        /*Person p = new Person();
        p.eat();
        Student student = new Student();
        student.sleep();*/
        //1.加载配置文件
        //1.1创建properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

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

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

    }
}

在以前，我们要实现别的类的别的方法时，就要重新创建一个类对象，对象调用实现方法，现在我们写好了这个简单的小框架，仅仅将配置文件中的className和methodName改成我们需要的就好了，极大的提升了效率。

来源：CSDN

作者：Stecolin

链接：https://blog.csdn.net/weixin_42656797/article/details/104348281