Java反射机制详解及实例练习【多测师_何sir】

1，什么是反射：
反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行时动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些类，这些类因为之前用不到，所以没有加载到jvm，这时，使用Java反射机制可以在运行期动态的创建对象并调用其属性，它是在运行时根据需要才加载。

2，简单总结反射：
就是在Java程序运行时可以动态往JVM的内存中加载类，并可以创建类对象来调用类中的方法和属性。

3，顺带总结创建类对象的四种方式：
new关键词，对象克隆，对象反序列化，反射

4，反射相关API类
接触过Java的一定知道，在Java的世界中一起皆对象。
那么Java中类编译后的字节码class文件也可以抽象成一个类。
一个class类文件中无非就包含了下面内容：
类名
构造方法
类变量
常量
实例变量
静态方法
实例方法

在Java中抽象class类的操作由Java虚拟机自动创建，并在内存中保存唯一个Class对象
Class类：
代表类的实体，在运行的Java应用程序中表示类和接口
Class类是Java对字节码class文件的抽象。

Field类
代表类的成员变量（成员变量也称为类的属性）
Field类是Java对字节码class文件中属性的抽象

Method类
代表类的方法
Method类是Java对字节码class文件中方法的抽象

Constructor类
代表类的构造方法
Constructor类是Java对字节码class文件中构造方法的抽象

5，反射详解
例如：
通过Java类来描述一条狗

package com.dcs;

/**
 * 定义一个狗的类
 */
public class Dog {
    // 名字
    private String name;
    // 年龄
    public int age;
    // 性别
    private String sex;

    // 无参构造方法
    public Dog() {
    }

    // 一个参数构造方法
    public Dog(String name) {
        this.name = name;
    }
    
    // 一个参数构造方法
    public Dog(int age) {
        this.age = age;
    }

    // 两个参数构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 三个参数私有构造方法
    private Dog(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("三个参数私有构造方法Dog.sex=" + sex);
    }

    // 公有方法
    public String dog1(String name, int age, String sex) {
        return name + "," + age + "," + sex;
    }

    // 私有方法
    private String dog3(String name, int age) {
        return name + ":" + age;
    }

    // 静态公有方法
    public static String dog2(String name) {
        return "静态公有方法=" + name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

通过反射来演示创建Dog对象并调用方法和访问属性

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

public class Demo {
    public static void main(String[] args) throws Exception {
        // 获取class对象,第一种方式
        Class<?> aClass = Class.forName("com.dcs.Dog");
        // 获取class对象,第二种方式
        Class<?> bClass = Dog.class;

        // 获取类名
        System.out.println("获取类名:" + aClass.getName());
        System.out.println("获取类名:" + bClass.getName());

        // 获取无参构造方法
        Constructor<?> constructor = aClass.getConstructor(null);
        // 构造方法的名字
        System.out.println(constructor.getName());
        // 通过构造方法创建对象
        Object o = constructor.newInstance();
        Dog dog = (Dog) o;
        dog.setName("旺财");
        System.out.println("获取无参构造方法:" + dog.getName());

        // 获取一个参数的构造方法
        Constructor<?> constructor1 = aClass.getConstructor(String.class);
        Object o1 = constructor1.newInstance("旺财");
        Dog dog1 = (Dog) o1;
        System.out.println("获取一个参数的构造方法:" + dog1.getName());

        Constructor<?> constructor2 = aClass.getConstructor(int.class);
        Object o2 = constructor2.newInstance(23);
        Dog dog2 = (Dog) o2;
        System.out.println("获取一个参数的构造方法:" + dog2.getAge());

        // 获取两个参数的构造方法
        Constructor<?> constructor3 = aClass.getConstructor(String.class, int.class);
        Object o3 = constructor3.newInstance("旺财", 23);
        Dog dog3 = (Dog) o3;
        System.out.println("获取两个参数的构造方法:" + dog3.getName() + ":" + dog3.getAge());

        // 获取私有的构造方法
        Constructor<?> constructor4 = aClass.getDeclaredConstructor(String.class, int.class, String.class);
        // 去掉java访问修饰符校验
        constructor4.setAccessible(true);
        Object o4 = constructor4.newInstance("旺财", 24, "公的");
        Dog dog4 = (Dog) o4;
        System.out.println("获取私有的构造方法:" + dog4.getName() + ":" + dog4.getAge());

        // 获取所有构造方法，不包含私有的
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor5 : constructors) {
            System.out.println("获取所有构造方法，不包含私有的:" + constructor5.getName());
        }

        // 获取所有构造方法，包含私有的
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("获取所有构造方法，包含私有的：" + declaredConstructor.getName());
        }

        // 获取公有非静态方法
        Object o5 = aClass.newInstance();
        Method method1 = aClass.getMethod("dog1", String.class, int.class, String.class);
        Object invoke = method1.invoke(o5, "旺财", 25, "母的");
        String string = invoke.toString();
        System.out.println("获取公有非静态方法：" + string);

        // 获取私有非静态方法
        Method method2 = aClass.getDeclaredMethod("dog3", String.class, int.class);
        // 去掉java访问修饰符校验
        method2.setAccessible(true);
        String string1 = method2.invoke(o5, "旺财", 26).toString();
        System.out.println("获取私有非静态方法:" + string1);

        // 获取静态公有方法
        Method method3 = aClass.getMethod("dog2", String.class);
        String string2 = method3.invoke(null, "小白").toString();
        System.out.println("获取静态公有方法：" + string2);

        // 获取所有方法,不包含私有方法,但包含继承和实现的方法
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println("获取所有方法,不包含私有方法,但包含继承和实现的方法:" + method.getName());
        }

        // 获取所有方法,包含私有方法,不包含继承和实现的方法
        Method[] methods1 = aClass.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println("获取所有方法,包含私有方法,不包含继承和实现的方法:" + method.getName());
        }

        // 获取类中的私有属性字段
        Object o6 = aClass.newInstance();
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o6, "大黄");
        Dog dog5 = (Dog) o6;
        System.out.println("获取指定的私有属性name并赋值：" + dog5.getName());

        // 获取类中的公有属性字段
        Field age = aClass.getField("age");
        // 为age设置值
        age.set(o6, 30);
        // 获取age的值
        age.get(o6);
        Dog dog6 = (Dog) o6;
        System.out.println("获取类中的公有属性字段：" + dog6.getAge());

        // 获取类中所有的属性字段，不包含私有的
        Field[] fields = aClass.getFields();
        for (Field field : fields) {
            System.out.println("获取类中所有的属性字段，不包含私有的：" + field.getName());
        }

        // 获取类中所有的属性字段，包含私有的
        Field[] fields1 = aClass.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println("获取类中所有的属性字段，包含私有的：" + field.getName());
        }
    }
}