java 反射

1. 先准备一个类 

package com.ggh.study;

public class Person extends Base {
    //Field
    public String publicPersonName;
    public int publicPersonAge;
    protected String protectedPerPersonName;
    protected int protectedPersonAge;
    private String privatePersonName;
    private int privatePersonAge;
    // Constructor
    public Person() { }
    public Person(String publicPersonName, int publicPersonAge, String protectedPerPersonName, int protectedPersonAge, String privatePersonName, int privatePersonAge) {
        this.publicPersonName = publicPersonName;
        this.publicPersonAge = publicPersonAge;
        this.protectedPerPersonName = protectedPerPersonName;
        this.protectedPersonAge = protectedPersonAge;
        this.privatePersonName = privatePersonName;
        this.privatePersonAge = privatePersonAge;
    }
    public Person(int publicBaseId, int protectedBaseId, int privateBaseId, String publicPersonName, int publicPersonAge, String protectedPerPersonName, int protectedPersonAge, String privatePersonName, int privatePersonAge) {
        super(publicBaseId, protectedBaseId, privateBaseId);
        this.publicPersonName = publicPersonName;
        this.publicPersonAge = publicPersonAge;
        this.protectedPerPersonName = protectedPerPersonName;
        this.protectedPersonAge = protectedPersonAge;
        this.privatePersonName = privatePersonName;
        this.privatePersonAge = privatePersonAge;
    }
    // getter setter
    public String getPublicPersonName() {
        return publicPersonName;
    }
    public void setPublicPersonName(String publicPersonName) {
        this.publicPersonName = publicPersonName;
    }
    public int getPublicPersonAge() {
        return publicPersonAge;
    }
    public void setPublicPersonAge(int publicPersonAge) {
        this.publicPersonAge = publicPersonAge;
    }
    public String getProtectedPerPersonName() {
        return protectedPerPersonName;
    }
    public void setProtectedPerPersonName(String protectedPerPersonName) {
        this.protectedPerPersonName = protectedPerPersonName;
    }
    public int getProtectedPersonAge() {
        return protectedPersonAge;
    }
    public void setProtectedPersonAge(int protectedPersonAge) {
        this.protectedPersonAge = protectedPersonAge;
    }
    public String getPrivatePersonName() {
        return privatePersonName;
    }
    public void setPrivatePersonName(String privatePersonName) {
        this.privatePersonName = privatePersonName;
    }
    public int getPrivatePersonAge() {
        return privatePersonAge;
    }
    public void setPrivatePersonAge(int privatePersonAge) {
        this.privatePersonAge = privatePersonAge;
    }
    //Method
    public String publicPersonMethod(String str, int i) {
        System.out.println("publicPersonMethod方法被执行");
        return "publicPersonMethod方法入参:" + str + " " + i;
    }
    protected String protectedPersonMethod(String str, int i) {
        System.out.println("protectedPersonMethod方法被执行");
        return "protectedPersonMethod方法入参:" + str + " " + i;
    }
    private String privatePersonMethod(String str, int i) {
        System.out.println("privatePersonMethod方法被执行");
        return "privatePersonMethod方法入参:" + str + " " + i; }
}

class Base {
    //Field
    public int publicBaseId;
    protected int protectedBaseId;
    private int privateBaseId;
    // Constructor
    public Base() { }
    public Base(int publicBaseId, int protectedBaseId, int privateBaseId) {
        this.publicBaseId = publicBaseId;
        this.protectedBaseId = protectedBaseId;
        this.privateBaseId = privateBaseId;
    }
    //getter setter
    public int getPublicBaseId() {
        return publicBaseId;
    }
    public void setPublicBaseId(int publicBaseId) {
        this.publicBaseId = publicBaseId;
    }
    public int getProtectedBaseId() {
        return protectedBaseId;
    }
    public void setProtectedBaseId(int protectedBaseId) {
        this.protectedBaseId = protectedBaseId;
    }
    public int getPrivateBaseId() {
        return privateBaseId;
    }
    public void setPrivateBaseId(int privateBaseId) {
        this.privateBaseId = privateBaseId;
    }
    // Method
    public String publicBaseMethod(String str, int i) {
        System.out.println("publicBaseMethod方法被执行");
        return "publicBaseMethod方法入参:" + str + " " + i;
    }
    protected String protectedBaseMethod(String str, int i) {
        System.out.println("protectedBaseMethod方法被执行");
        return "protectedBaseMethod方法入参:" + str + " " + i;
    }
    private String privateBaseMethod(String str, int i) {
        System.out.println("protectedBaseMethod方法被执行");
        return "privateBaseMethod方法入参:" + str + " " + i;
    }
}

2. 使用反射

package com.ggh.study;

import java.lang.reflect.*;

public class ReflectUse {
    public static void main(String[] args) {
        /**
         * class Class 用来存储类
         * class Field 用来存储属性
         * class Constructor 用来存储构造方法
         * class Method 用来存储非构造方法
         * class Modifier 用来判断修饰符
         */


        /*获取类*/

        //方法一
        Class clazz1 = Person.class;
        // 获取类的修饰符代号
        int modifier1 = clazz1.getModifiers();
        // 判断类的修饰符
        System.out.println(Modifier.isPublic(1));
        System.out.println(Modifier.isPrivate(3));
        System.out.println(Modifier.isProtected(4));
        System.out.println(Modifier.isStatic(8));
        System.out.println(Modifier.isFinal(20));
        System.out.println(Modifier.isSynchronized(40));
        System.out.println(Modifier.isVolatile(100));
        System.out.println(Modifier.isTransient(200));
        System.out.println( Modifier.isNative(400));
        System.out.println(Modifier.isInterface(1000));
        System.out.println(Modifier.isAbstract(2000));
        System.out.println(Modifier.isStrict(4000));

        //方法二
        Class clazz2 = null;
        try {
            clazz2 = Class.forName("com.ggh.study.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //方法三
        Person person = new Person();
        Class clazz3 = person.getClass();


        /*获取构造方法*/

        //获取全部公有构造方法 (不包括继承类的公有构造)
        Constructor[] constructors1 = clazz1.getConstructors();

        //获取指定无参公有构造（不能指定继承类的公有构造）
        Constructor constructor1 = null;
        try {
            constructor1 = clazz1.getConstructor();
        } catch (NoSuchMethodException e) {
            e.printStackTrace(); }

        //获取指定有参公有构造（不能指定继承类的公有构造）
        Constructor constructor2 = null;
        try {
            constructor2 = clazz1.getConstructor(new Class[]{int.class, int.class, int.class, String.class, int.class, String.class, int.class, String.class, int.class}); //方法参数:（1）new Class[]{构造参数的入参类型} （1）构造参数的入参类型
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }


        /*调用构造方法*/

        //调用指定无参构造 方法一
        Person person1 = null;
        try {
            person1 = (Person) constructor1.newInstance();
            // 获取完整类名（包括包名）
            String constructorName1 = constructor1.getName();
            // 获取完整方法名（包括饰符名 完整类名 参数类型完整类名）
            String constructorName2 = constructor1.toString();
            // 获取修饰符代号
            int modifier2 = constructor1.getModifiers();
        }
        catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        //调用指定无参构造 方法二
        Person person2 = null;
        try {
            person2 = (Person) clazz1.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        //调用指定有参构造
        Person person3 = null;
        try {
            person3 = (Person) constructor2.newInstance(1, 2, 3, "public_name", 11, "protected_name", 12, "private_name", 13); //方法入参:填入调用指定有参构造时想要传入的数据
            // 获取完整类名（包括包名）
            String constructorName1 = constructor2.getName();
            // 获取完整方法名（包括饰符名 完整类名 参数类型完整类名）
            String constructorName2 = constructor2.toString();
            // 获取修饰符代号
            int modifier3 = constructor2.getModifiers();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }


        /*获取非构造方法*/

        //获取所有非构造方法(不包括继承类的非构造方法)
        Method[] declaredMethods1 = clazz1.getDeclaredMethods();

        // 获取指定的非构造方法（不能指定继承类的非构造方法）
        Method declaredMethod1 = null;
        Method declaredMethod2 = null;
        try {
            // 获取受保护方法
            declaredMethod1 = clazz1.getDeclaredMethod("protectedPersonMethod", new Class[]{String.class, int.class}); //方法入参:（1）想要获取的非构造方法的名称 （2）new Class[]{想要获取的非构造方法的入参类型}
            // 获取私有方法
            declaredMethod2 = clazz1.getDeclaredMethod("privatePersonMethod", new Class[]{String.class, int.class}); //方法入参:（1）想要获取的非构造方法的名称 （2）new Class[]{想要获取的非构造方法的入参类型}
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

        //获取所有非构造公有方法（包括继承类的公用非构造方法 + Object类的公有非构造方法）
        Method[] methods1 = clazz1.getMethods();

        //获取指定的非构造公有方法(也可以指定继承类的非构造公有方法)
        Method method1 = null;
        Method method2 = null;
        Method method3 = null;
        try {
            method1 = clazz1.getMethod("getPublicPersonName"); //方法入参: 想要获取的非构造公有方法的名称
            method2 = clazz1.getMethod("publicPersonMethod", new Class[]{String.class, int.class}); //方法入参: （1）想要获取的非构造公有方法的名称 （2）new Class[]{想要获取的非构造公有方法的入参类型}
            // 获取继承类的指定非构造公有方法
            method3 = clazz1.getMethod("publicBaseMethod", String.class, int.class); //方法入参: （1）想要获取的非构造公有方法的名称 （2）想要获取的非构造公有方法的入参类型
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }


        /*调用非构造方法*/

        //调用指定的非构造方法
        String methodReturn1 = null;
        String methodReturn2 = null;
        try {
            // 调用受保护方法
            methodReturn1 = (String) declaredMethod1.invoke(person1, "protected_person_name", 21); //方法入参:(1)填入一个你想要调用的非构造方法所在的类的实例对象 （2）填入调用指定非构造方法时想要传入的参数
            // 关闭declaredMethod2的安全检查。关闭declaredMethod2包含的私有方法的安全检查，才允许通过declaredMethod1调用私有方法，调用公有方法和受保护方法不需要
            declaredMethod2.setAccessible(true);
            // 调用私有方法
            methodReturn2 = (String) declaredMethod2.invoke(person1, "private_person_name", 22); //方法入参:(1)填入一个你想要调用的非构造方法所在的类的实例对象 （2）填入调用指定非构造方法时想要传入的参数
            // 获取方法名
            String name1 = declaredMethod1.getName(); //获取方法完整名（包括修饰符名 返回类型名 完整类名 参数类型完整类名）
            String mame2 = declaredMethod1.toString();
            // 获取修饰符代号
            int modifier4 = declaredMethod1.getModifiers();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        //调用指定的非构造公有方法
        String methodReturn3 = null;
        String methodReturn4 = null;
        String methodReturn5 = null;
        try {
            methodReturn3 = (String) method1.invoke(person1); //方法入参:填入一个你想要调用的非构造公有方法所在的类的实例对象
            methodReturn4 = (String) method2.invoke(person1, "public_person_method", 31); //方法入参:（1）填入一个你想要调用的非构造公有方法所在的类的实例对象 （2）填入调用指定非构造公有方法时想要传入的参数
            // 调用继承类的指定非构造公有方法
            methodReturn5 = (String) method3.invoke(person1, "public_base_method", 41); //方法入参:（1）填入一个你想要调用的非构造公有方法所在的类的实例对象 （2）填入调用指定非构造公有方法时想要传入的参数
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }


        /*获取属性*/

        //获取所有属性(不包括继承类的属性)
        Field[] declaredFields1 = clazz1.getDeclaredFields();

        //获取指定的属性(可以指定继承类的属性)
        Field declaredField1 = null;
        Field declaredField2 = null;
        Field declaredField3 = null;
        try {
            declaredField1 = clazz1.getDeclaredField("publicPersonName"); //方法入参:想要获取的属性的名称
            declaredField2 = clazz1.getDeclaredField("protectedPerPersonName");
            declaredField3 = clazz1.getDeclaredField("privatePersonName");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        //获取所有公有属性（包括继承的类的公有属性）
        Field[] fields1 = clazz1.getFields();

        //获取指定的公有属性（可以指定继承的类的公有属性）
        Field declaredField4 = null; Field declaredField5 = null;
        try {
            declaredField4 = clazz1.getField("publicPersonName"); //方法入参:想要获取的公有属性的名称
            declaredField5 = clazz1.getField("publicBaseId");
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }


        /*调用属性*/

        //调用指定属性的getter setter （与getter setter有无 无关）
        String fieldName1 = null;
        String fieldName2 = null;
        String fieldName3 = null;
        try {
            // 调用指定setter
            declaredField1.set(person1, "public_person_name"); //方法入参:（1）填入一个你想要调用的setter所在的类的实例对象 （2）填入调用setter时想要传入的参数
            // 调用指定getter
            fieldName1 = (String) declaredField1.get(person1); //方法入参:填入一个你想要调用的getter所在的类的实例对象
            declaredField2.set(person1, "protected_person_name");
            fieldName2 = (String) declaredField2.get(person1);
            // 关闭declaredField3的安全检查。关闭私有属性对应的Field对象的安全检查，才能调用私有方法，调用公有方法和受保护方法不需要
            declaredField3.setAccessible(true);
            declaredField3.set(person1, "private_person_name");
            fieldName3 = (String) declaredField3.get(person1);
            // 获取属性名
            String field1Name1 = declaredField1.getName();
            // 获取属性值
            String field1Name2 = declaredField1.toString();
            // 获取修饰符代号
            int modifier5 = declaredField1.getModifiers();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        //调用指定属性的公有getter setter
        String fieldName4 = null;
        int fieldName5;
        try {
            // 调用本类指定公有setter getter
            declaredField4.set(person1, "public_person_name"); //方法入参:（1）填入一个你想要调用的公有setter所在的类的实例对象 （2）填入调用公有setter时想要传入的参数
            fieldName4 = (String) declaredField4.get(person1); //方法入参:填入一个你想要调用的公有getter所在的类的实例对象
            // 调用继承类指定公有setter getter
            declaredField5.set(person1, 4);
            fieldName5 = (int) declaredField5.get(person1);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}