获取构造方法

Stu类

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

    public Stu() { }

    public Stu(String name) { this.name = name; }
    
    protected Stu(int age) { this.age = age; }

    private Stu(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 适用场景：适用于类名在编译期不确定，需要动态指定的场景（如数据库驱动加载）
// 常用
Class clazz = Class.forName("com.mao.Stu");

// 适用场景：适用于编译期已知类名的情况，写法简洁，性能略优
// 一般当做参数进行传递
Class clazz1 = Stu.class;

// 适用场景：已经持有对象实例，需要通过对象反推其类信息的场景（如多态中获取实际运行时类）
// 当有这个类时，才可以使用
Stu stu = new Stu();
Class clazz2 = stu.getClass();

System.out.println(clazz == clazz1);    // true
System.out.println(clazz == clazz2);    // true
System.out.println(clazz1 == clazz2);   // true

获取构造方法（public）

//        获取构造方法
        Constructor[] cons = clazz.getConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
//        输出：
//        public com.mao.Stu()
//        public com.mao.Stu(java.lang.String)

获取所有构造方法

//        获取所有构造方法
        Constructor[] all = clazz.getDeclaredConstructors();
        for (Constructor con : all) {
            System.out.println(con);
        }
//        输出：
//        public com.mao.Stu()
//        private com.mao.Stu(java.lang.String,int)
//        protected com.mao.Stu(int)
//        public com.mao.Stu(java.lang.String)

获取单个构造函数

//        获取单个构造函数
//        括号中输入对应构造方法中的形参类
        Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);
//        输出：
//        private com.mao.Stu(java.lang.String,int)

获取参数的详细信息

        Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
//        作用：获取参数的详细信息，包括参数类型、参数名（需特定条件）、注解等
        Parameter[] parameters = con.getParameters();
        for (Parameter p : parameters) {
            System.out.println(p);
        }
//        输出
//        java.lang.String arg0
//        int arg1

调用类中的构造方法

        Constructor con = clazz.getDeclaredConstructor(String.class, int.class);
//        打破 Java 的访问权限控制
        con.setAccessible(true);
//        调用类中的构造方法
        Stu stu1 = (Stu) con.newInstance("张三", 20);
        System.out.println(stu1);	// 张三 20
        Stu stu2 = (Stu) con.newInstance("李四", 22);
        System.out.println(stu2);	// 李四 22

获取变量

Stu类

public class Stu {
    private String name;
    private int age;
    public String gender;

    public Stu(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
}

获取所有成员变量

        Class clazz = Class.forName("com.mao.Stu");
//        获取所有成员变量
        Field[] fields = clazz.getDeclaredFields();
        for (Field f : fields) {
            System.out.println(f);
        }
//        输出
//        private java.lang.String com.mao.Stu.name
//        private int com.mao.Stu.age

获取单个成员变量

//        获取单个成员变量
//        括号中输入对应的变量名
        Field field = clazz.getDeclaredField("age");
        System.out.println(field);
//        输出
//        private int com.mao.Stu.age

获取成员变量名

//        获取成员变量的名字
        Field field1 = clazz.getDeclaredField("age");
        String name = field1.getName();
        System.out.println(name);
//        输出：age

获取成员变量的类型

//        获取成员变量的类型
        Field field2 = clazz.getDeclaredField("age");
        Class type = field2.getType();
        System.out.println(type);
//        输出：int

获取成员变量的值

//        获取成员变量的值
        Field field3 = clazz.getDeclaredField("name");
        Stu stu = new Stu("张三", 20, "男");
        field3.setAccessible(true);
        String name1 = (String) field3.get(stu);
        System.out.println(name1);
//        输出：张三

修改成员变量的值

//        修改成员变量的值
        Field field4 = clazz.getDeclaredField("name");
        Stu stu1 = new Stu("张三", 20, "男");
        field4.setAccessible(true);
        field4.set(stu1, "李四");
        System.out.println(stu1);	// 李四 20 男

获取方法

Stu类

public class Stu {
    private String name;
    private int age;
    public String gender;
    public String info(String name) throws IOException {
        return name;
    }
    public void info(String name, int age) { }
}

获取所有方法

Class clazz = Class.forName("com.mao.Stu");
//        获取所有方法（包括父类的方法）
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

//        获取所有方法（不包括父类的方法）
        Method[] methods1 = clazz.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }

获取指定方法

//        获取指定的单一方法
        Method method = clazz.getDeclaredMethod("info", String.class, int.class);
        System.out.println(method);
//        输出
//        public void com.mao.Stu.info(java.lang.String,int)

获取方法名

//        获取方法名
        Method method1 = clazz.getDeclaredMethod("info", String.class, int.class);
        String name = method1.getName();
        System.out.println(name);
//        输出：info

获取方法的形参

//        获取方法的形参
        Method method2 = clazz.getDeclaredMethod("info", String.class, int.class);
        Parameter[] parameters = method2.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }
//        输出：
//        java.lang.String arg0
//        int arg1

获取方法抛出的异常

//        获取方法抛出的异常
        Method method3 = clazz.getDeclaredMethod("info", String.class);
        Class[] exceptionName = method3.getExceptionTypes();
        for (Class exception : exceptionName) {
            System.out.println(exception);
        }
//        输出：class java.io.IOException

获取方法的返回值

//        获取方法的返回值
        Method method4 = clazz.getDeclaredMethod("info", String.class);
        Stu stu = new Stu();
        method4.setAccessible(true);
        String returnName = (String) method4.invoke(stu, "h");
        System.out.println(returnName);
//        输出：h