java反射

手动编写的对象都会创建一个Class对象,对象中的所有属性都封装在Filed[] 数组中，所有方法都封装在 Method[] 数组中，所有构造函数都封装在 Constructor[] 数组中，通过反射可以在程序运行过程中，确定一个对象的类，找出一个成员变量（Filed），成员方法（Method）和构造函数（Constructor），包括从父类中继承的变量和方法，主要应用在框架中。因为Class对象的构造函数是私用的，所以只能通过JVM创建和加载。反射的缺点主要有两个，第一反射中包括一些动态类型，所以JVM无法对这些类进行优化，调用起来比较慢；第二，反射允许正常情况下无法执行的操作，有时会破坏面向对象的封装特性。

本文为学习黑马陈长宏老师讲解的反射视频的学习笔记，视频链接见文章末尾。

1. 通过反射Class的和创建对象

创建class的三种方式
（1）通过对象引用调用getClass（）
（2）通过类名.Class创建
（3） 通过调用Class.forName(全类名)创建
note:同一个类型不同方式创建的Class都是是同一个
创建对象的两种方式
（1）使用clazz.newInstance(),该方法要求对应class有默认构造方法，newInstance()方法实际调用了类的默认无参构造方法
（2）使用clazzs获得对应的Constructor,然后再使用Constructor.newInstance()方法创建对象，该方法可以获得不同参数的构造函数

1.1 待反射的类Person

public class Person {
    private int age;
    private String name;
    public Person(){}
    public Person(int age,String name){
        this.age = age;
        this.name = name;
    }
    public void playPiano(String str){
        System.out.println("正在弹奏\t"+str);
    }
    private void myFunc(){
        System.out.println("private method...");
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

1.2 反射演示

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo {
    public static void main(String[] args) throws Exception {

        Person p1 = new Person();
        Person p2 = new Person();
        Class class1 = p1.getClass();
        Class class2 = p2.getClass();
        System.out.println(class1 ==class2);

        Class class3 = Person.class;
        System.out.println(class1 == class3);

        Class class4 = Class.forName("test.Person");
        System.out.println(class3 == class4);

        /***
         * 创建对象两种方式
         *      1.使用clazz.newInstance(),该方法要求对应class有默认构造方法，newInstance()方法里面调用了类的
          *     默认构造方法。
         *      2.先使用Class获得对应的Constructor,然后再使用Constructor.newInstance()方法创建对象，该方法可以创建
         *      指定参数的构造方法。
         *
         */
        Person p3 = (Person) class4.newInstance();
        System.out.println(p3);

        Constructor constructor = class4.getConstructor(int.class,String.class);
        Person p4 = (Person) constructor.newInstance(15,"zhangsan");
        System.out.println(p4);


    }
}

2.成员方法的获取和调用

成员方法的获取
（1）getMethod(方法名，参数class类型…)，获取制定名字和参数的方法
（1）getMethods()获得类中所有public方法；
（2）getDeclaredMethods()是获取所有类中所有方法，包括私有方法和公共方法。
成员方法的调用：
(1)method.invoke(对象，参数…)
note:调用私有方法之前要先设置setAccessilbe(true)

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        /**（对于构造函数和属性访问和方法类似，此处值详细列举使用反射获取方法和使用方法的用法）
         * 通过clazz获取对象中方法的三种方式
         *    1.获取对象中的具体名字的参数，使用clazz.getMethod(方法名,参数class类型);
         *    2.获取对象中所有共有方法
         *    3.获得对象中所有方法，包括共有方法和私有方法
         *通过clazz方法调用的两种形式
         *    1.调用共有方法method.invoke(对象，参数值);
         *    2.调用私有方法，使用clazz.getDeclaredMethod(方法名，参数)，method.setAccessible(true)设置私有方法可以访问
         */
        Class clazz = Class.forName("test.Person");
        Method method1 = clazz.getMethod("getAge");
        System.out.println(method1+"\t AAA \t"+method1.getName());
        Method[] methods = clazz.getMethods();
        System.out.println("显示对象中所有共有方法。。。");
        for(Method method: methods){
            System.out.println(method.getName());
        }
        System.out.println("显示对象中所有方法。。。");
        Method[] methods2 = clazz.getDeclaredMethods();
        for(Method method: methods2){
            System.out.println(method.getName());
        }

        //方法调用
        Method method2 = clazz.getMethod("playPiano", String.class);
        Person person = new Person();
        method2.invoke(person,"茉莉花");

        //调用私有方法
        Method method3 = clazz.getDeclaredMethod("myFunc");
        method3.setAccessible(true);
        method3.invoke(person);
    }
}

3.编写一个框架，在不改变任何代码的情况下，实现创建不同的类，调用不同的方法

主要使用反射+配置文件进行实现，将要创建的类和调用方法写在配置文件里，读取配置文件中信息，通过方法创建对应对象，调用对应方法，要向创建新的类和新的方法，只需修改配置文件即可。

3.1配置文件信息(pro.properties)

className= test.Person
methodName = playPiano

3.2 反射框架演示

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

public class ReflectFrameDemo {
    public static void main(String[] args) throws Exception {
        //加载配置文件，转化为一个集合
        Properties pro = new Properties();
        ClassLoader loader = ReflectFrameDemo.class.getClassLoader();
        InputStream is = loader.getResourceAsStream("pro.properties");
        pro.load(is);
        
        //读取配置文件中信息
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");
        
        //通过反射创建对象和调用方法
        Class clazz = Class.forName(className);
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod(methodName,String.class);
        method.invoke(obj,"茉莉花");
    }
}

Reference

[1] https://www.bilibili.com/video/BV1C4411373T?t=440&p=7.