Java 反射浅析与使用

获取Class对象

加载class的方式

1. 通过Class.forName(className) className：全类名(类包名+类名)
2. 通过类名.class方法获取
3. 通过对象的getClass()方法获取

            Class aClass = Class.forName("com.hww.test.Info");
            System.out.println("Class.forName 方式获取：" + aClass);
            Class aClass2 = Info.class;
            System.out.println("方法名.class 方式获取：" + aClass2);
            Info info = new Info();
            Class aClass3 = info.getClass();
            System.out.println("对象.getClass 方式获取：" + aClass3);


执行结果：
Class.forName 方式获取：class com.hww.test.Info
方法名.class 方式获取：class com.hww.test.Info
对象.getClass 方式获取：class com.hww.test.Info

获取构造方法

获取构造函数的方法

1. getConstructors() 返回该类声明的所有公共构造函数
2. getDeclaredConstructors() 返回该类声明的所有构造函数
3. getConstructor(Class… parameterTypes) 返回指定公共构造函数
4. getDeclaredConstructor(Class… parameterTypes) 返回指定构造函数

            Class aClass = Class.forName("com.hww.test.Info");
            Constructor[] constructors = aClass.getConstructors();/*获取所有的公开构造方法*/
            Constructor[] constructorsDec = aClass.getDeclaredConstructors();/*获取所有的构造方法*/

            System.out.println("获取所有的公开构造方法 === getConstructors");
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }
            System.out.println("获取所有的构造方法 === getDeclaredConstructors");
            for (Constructor constructor : constructorsDec) {
                System.out.println(constructor);
            }

            Constructor constructor = aClass.getConstructor();/*返回指定公共构造函数*/
            System.out.println("返回指定公共构造函数 === getConstructor    " + constructor);

            Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class);/*返回指定构造函数*/
            System.out.println("返回指定构造函数 === getDeclaredConstructor    " + declaredConstructor);

            /*获取到构造方法后，初始化对象*/
            declaredConstructor.setAccessible(true);/*设置安全检查的标志位，true取消安全检查*/
            Object newInstance = declaredConstructor.newInstance("张三");
            System.out.println("通过构造方法创建对象：" + newInstance);

            /*该方法在java9中被标记为过时，推荐使用 clazz.getDeclaredConstructor().newInstance() */
            Object newInstance1 = aClass.newInstance();
            System.out.println("直接通过newInstance方法创建对象：" + newInstance1);


执行结果：
获取所有的公开构造方法 === getConstructors
public com.hww.test.Info(java.lang.String,int)
public com.hww.test.Info()
获取所有的构造方法 === getDeclaredConstructors
public com.hww.test.Info(java.lang.String,int)
private com.hww.test.Info(java.lang.String)
public com.hww.test.Info()
返回指定公共构造函数 === getConstructor    public com.hww.test.Info()
返回指定构造函数 === getDeclaredConstructor    private com.hww.test.Info(java.lang.String)
执行了private带参构造函数  参数内容：张三
通过构造方法创建对象：com.hww.test.Info@1c20c684
执行了public无参构造函数
直接通过newInstance方法创建对象：com.hww.test.Info@1fb3ebeb

获取成员变量

获取成员变量的方法

1. getFields();/获取类中所有的public成员变量/
2. getDeclaredFields();/获取类中所有的成员变量/
3. getField(“age”);/获取类中指定的public成员变量/
4. getDeclaredField(“name”);/获取类中指定的成员变量/

/*获取类的所有成员变量*/
        Field[] fields = aClass.getFields();/*获取类中所有的public成员变量*/
        System.out.println("获取类中所有的public成员变量： getFields");
        for (Field field : fields) {
            System.out.println(field);
        }
        Field[] declaredFields = aClass.getDeclaredFields();/*获取类中所有的成员变量*/
        System.out.println("获取类中所有的成员变量： getDeclaredFields");
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        Field field = aClass.getField("age");/*获取类中指定的public成员变量*/
        System.out.println("获取类中指定的public成员变量 getField : " + field);
        Field declaredField = aClass.getDeclaredField("name");/*获取类中指定的成员变量*/
        System.out.println("获取类中指定的成员变量 getDeclaredField : " + declaredField);

        /*获取成员变量的值或修改成员变量的值*/
        Constructor declaredConstructor = aClass.getDeclaredConstructor();/*获取一个无参构造函数*/
        Object newInstance = declaredConstructor.newInstance();/*创建对象*/
        System.out.println("修改前对象的内容：" + newInstance.toString());
        declaredField.setAccessible(true);/*设置安全检查的标志位，true取消安全检查*/
        declaredField.set(newInstance, "李四");
        System.out.println("修改后对象的内容：" + newInstance.toString());

        /*单独获取成员变量的值*/
        Object get = declaredField.get(newInstance);
        System.out.println("单独获取成员变量的值： " + get);


执行结果：
获取类中所有的public成员变量： getFields
public int com.hww.test.Info.age
获取类中所有的成员变量： getDeclaredFields
private java.lang.String com.hww.test.Info.name
public int com.hww.test.Info.age
获取类中指定的public成员变量 getField : public int com.hww.test.Info.age
获取类中指定的成员变量 getDeclaredField : private java.lang.String com.hww.test.Info.name
执行了public无参构造函数
修改前对象的内容：Info{name='null', age=0}
修改后对象的内容：Info{name='李四', age=0}
单独获取成员变量的值： 李四

#获取成员方法
获取成员方法：

1. getMethods();/该方法返回类中所有的公共方法，包括由类或接口声明的对象，以及超类和超级接口继承的类/
2. getDeclaredMethods();/该方法返回类中定义所有的方法，不包括继承方法/
3. getMethod(“show3”, String.class);/返回一个指定方法名的公共方法对象 参数1：方法的名称 参数2：参数数组/
4. getDeclaredMethod(“show1”);/返回一个指定方法名的方法对象 参数1：方法的名称 参数2：参数数组/

Method[] methods = aClass.getMethods();/*该方法返回类中所有的公共方法，包括由类或接口声明的对象，以及超类和超级接口继承的类*/
        System.out.println("获取类中所有公共方法，包含继承类的  getMethods ");
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("该方法返回类中定义所有的方法，不包括继承方法  getDeclaredMethods ");
        Method[] declaredMethods = aClass.getDeclaredMethods();/*该方法返回类中定义所有的方法，不包括继承方法*/
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        Object o = aClass.getDeclaredConstructor().newInstance();/*通过无参构造创建一个对象*/
        Method method = aClass.getMethod("show3", String.class);/*返回一个指定方法名的公共方法对象    参数1：方法的名称 参数2：参数数组*/
        Object invoke = method.invoke(o, "张三");
        System.out.println("invoke 调用有参有返回内容接口，返回值：" + invoke);

        /*执行无参无返回值的private方法  需要注意的是，调用无参方法的时候参数2可以不需要填写内容或填写null*/
        Method method1 = aClass.getDeclaredMethod("show1",null);/*返回一个指定方法名的方法对象    参数1：方法的名称 参数2：参数数组*/
        method1.setAccessible(true);/*设置安全检查的标志位，true取消安全检查*/
        Object invoke1 = method1.invoke(o);/*当前方法无返回值，创建了接收对象，内容为null*/
        System.out.println("invoke 调用无参无返回的private方法成功" + invoke1);

执行结果：
获取类中所有公共方法，包含继承类的  getMethods 
public java.lang.String com.hww.test.Info.toString()
public void com.hww.test.Info.show2(java.lang.String)
public java.lang.String com.hww.test.Info.show3(java.lang.String)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
该方法返回类中定义所有的方法，不包括继承方法  getDeclaredMethods 
public java.lang.String com.hww.test.Info.toString()
private void com.hww.test.Info.show1()
public void com.hww.test.Info.show2(java.lang.String)
public java.lang.String com.hww.test.Info.show3(java.lang.String)
执行了public无参构造函数
===>执行 show3 方法    参数内容：张三
invoke 调用有参有返回内容接口，返回值：show3返回的内容
===>执行 show1 方法
invoke 调用无参无返回的private方法成功null

Process finished with exit code 0

测试中使用到的类对象

package com.hww.test;

public class Info {
    private String name;
    public int age;

    public Info() {
        System.out.println("执行了public无参构造函数");
    }

    private Info(String name) {
        this.name = name;
        System.out.println("执行了private带参构造函数  参数内容：" + name);
    }

    public Info(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("执行了public带参构造函数  参数内容,name=" + name + " age=" + age);
    }


    private void show1() {
        System.out.println("===>执行 show1 方法");
    }

    public void show2(String str) {
        System.out.println("===>执行 show2 方法    " + str);
    }

    public String show3(String str) {
        System.out.println("===>执行 show3 方法    参数内容：" + str);
        return "show3返回的内容";
    }

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