Java反射机制

        java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

        对于任意一个对象，都能够调用它的任意方法和属性；

        这种动态获取信息以及动态调用对象方法的功能称之为Java反射机制；

        简单来说，反射机制指的是程序在运行时能够获取自身的信息。

        想要解刨一个类，必须要获取到该类的Class对象，而剖析一个类活用反射解决具体的问题就是使用相关的API：

1. java.lang.Class
2. java.lang.reflect

所以，Class对象是反射机制的根源

首先，自定义一个实体类

public class Dog{


    private String name;

    private int age;

    private String color;

    /**
        无参构造
    */

    public Dog(){

    }

    /**
        有参构造
    */
    public Dog(String name, int age, String color){
        this name = name;
        this age = age;
        this color = color;
    
    }

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

    public String getName(){
        return name;
    }

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

    public String getAge(){
        return age;
    }

    public void setColor(String color){
        this.color = color;
    }

    public String getColor(){
        return color;
    }

}

然后通过反射机制来获取Class对象的多种方式、获取构造方法、属性、方法

public class Test{
    
    /**
        三种方式获取Class对象：
            1.通过类名.Class来获取
            2.通过对象.getClass()来获取
            3.通过Class.forName("类的全路径")来获取
    */
    public void test1() throws Exception {
    
        // 如test1方法上的注解1所示
        Class class1 = Dog.calss;

        // 如test1方法上的注解2所示
        Class class2 = new Dog().getClass();

        // 如test1方法上的注解3所示
        Class class3 = Class.forName("类的全路径");
        
        Dog dog = (Dog)class3.newInstance();
        
        System.out.println(dog);
    
    }
    
    /**
        通过反射获取类的构造方法：
           1.获取public的构造方法用getConstructors();
           2.如果是private就用getDeclaredConstructors();
    */
    public void test2() throws Exception {
        
        Class class1 = Dog.calss;
        
        Constructors[] constructors = class1.getConstructors();
        for (Constructors constr : constructors){
            System.out.println("方法名称：" + constr.getName() + 
                               "方法个数：" + constr.getParameterCount());
            
        }

        // 如test2方法上的注解1所示
        Constructors constrs = class1.getConstructors(String class, int class,
                                                              String class);
        Dog dog = (Dog)constrs.newInstance("蹦蹦",5,"奶白色");
        System.out.println("public构造：" + dog)

        // 如test2方法上的注解2所示
        Constructors constrs = class1.getDeclaredConstructors(String class, int class,
                                                              String class);
        // 允许访问private属性的构造
        constrs.setAccessible(true);
        Dog dog = (Dog)constrs.newInstance("法国斗牛犬",5,"黑色");
        System.out.println("private构造" + dog)
    }

    /**
        通过反射获取对象的属性：
           1.如果是public就用getFields();
           2.如果private也想获取到就用getDeclaredFields();
    */
    public void test3() throws Exception {
        
        Class class1 = Dog.calss;

        Dog dog = (Dog)class1.newInstance();

        // 如test3方法上的注解1所示
        Fields[] fields = class1.getFields();

        // 如test3方法上的注解2所示
        Fields[] fields = class1.getDeclaredFields();
        for (Fields field = fields){
            // 判断该属性的值等于name
            if(field.getName().equals("name")){
                // 允许访问private属性的方法
                field.setAccessible(true);
                // 设置属性值
                field.set(Dog,"法国斗牛犬");
            }
            System.out.println(field.getName());
            System.out.println(Dog);
        }
    }

    /**
        通过反射获取对象的方法：
            1.获取public方法使用getMethod();
            2.获取包含private方法
    */
    public void test4() throws Exception {

        Dog dog = new Dog("蹦蹦",5,"奶白色");
        Class class1 = dog.getClass();
        // 如test4方法的注解1所示
        Method[] methods = class1.getMethod();
        for(Method method : methods){
            System.out.println("public方法：" + method.getName);
            // 判断方法名称是否为想要执行的方法名称
            if(method.getName().equals("方法名称")){
                //     执行方法
                method.invoke(dog);
            }
        }
        // 如test4方法上的注解2所示
        Method[] methods = class1.getDeclaredMethod();
        for(Method method : methods){
            System.out.println("private方法：" + method.getName);
            // 判断方法名称是否为想要执行的方法名称
            if(method.getName().equals("方法名称")){
                // 允许访问private属性的方法
                method.setAccessible(true)；
                // 执行方法
                method.invoke(dog);
            }
        }
    }
}

简单示例纯属自己理解，欢迎各位大神指正。