reflect 反射

1：任何对象的创建依赖于字节码

2：运行状态中，对于任意一个类（class文件），都能直到其中的所有属性与方法。

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

   这样的动态获取信息以及动态调用对象的方法的功能成为java语言的反射  

3：应用程序，独立运行。。对外提供接口是为了扩展（不能修改源代码的时候，使用代理方式）。

      拿到对外暴漏的接口名（通过配置文件），然后通过反射获取类里面的信息。拿到类名称，可以找到类文件，获得字节码文件

4：类，属性，方法，构造器准备

　　

public class Cat {

    private String color;
    public double weight;

    public String eat(String food) {
        System.out.println("今晚cat吃了：" + food);
        return food;
    }
    private void sleep(Integer num, String color) {
        System.out.println(num + "个颜色是" + color + "的猫猫在睡觉");
    }

    public Cat() {
    }
    private Cat(String color, double weight) {
        this.color = color;
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "Cat{" +
                "color='" + color + '\'' +
                ", weight=" + weight +
                '}';
    }
}

5：利用反射获取信息

public class CatRefect {
    /**
     * 获取Class的字节码:java.lang.class对象的三种方法
     */
    @Test
    public void getClassOfObject() throws ClassNotFoundException {
        Class<?> catClass_class = Cat.class;
        Class<?> catClass_ForName = Class.forName("com.zsc.reflect.Cat");
        Class<?> catClass_getClass = new Cat().getClass();
    }

    @Test
    public void getClassName() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        String name = clazz.getName();
        System.out.println("name==" + name);    //name==com.zsc.reflect.Cat
    }

    /**
     * 获取public构造器
     */
    @Test
    public void getPublicContrucate() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");

        Cat catByBewInstance = (Cat) clazz.newInstance();
        catByBewInstance.eat("mouse"); //今晚cat吃了：mouse

        Constructor<?> declaredConstructor = clazz.getConstructor();
        Cat cat = (Cat) declaredConstructor.newInstance();
        cat.eat("rat"); //今晚cat吃了：rat
    }

    /**
     * 获取private构造器
     */
    @Test
    public void getPrivateContrucate() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class, double.class);
        declaredConstructor.setAccessible(true);    //访问“私有属性、私有构造器、私有方法”必须设置此值
        Cat cat = (Cat) declaredConstructor.newInstance("wright", 10.01);
        System.out.println(cat);      //Cat{color='wright', weight=10.01}
        cat.eat("rat");         //今晚cat吃了：rat
    }

    /**
     * 获取全部的public构造器
     */
    @Test
    public void getAllPublicContrucate() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Constructor<?>[] constructors = clazz.getConstructors();

        for (Constructor<?> constructor : constructors) {
            String name = constructor.getName();
            System.out.println("publicConstructorName==" + name);   // publicConstructorName==com.zsc.reflect.Cat  共1个
        }
    }

    /**
     * 获取全部的all构造器
     */
    @Test
    public void getAllContrucate() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();

        for (Constructor<?> constructor : constructors) {
            String name = constructor.getName();
            System.out.println("publicConstructorName==" + name);
            // publicConstructorName==com.zsc.reflect.Cat  共2个
            // publicConstructorName==com.zsc.reflect.Cat
        }
    }

    /**
     * 获取指定的public属性
     */
    @Test
    public void getOnePublicField() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Field field = clazz.getDeclaredField("weight");
        String name = field.getName();
        System.out.println(name);   //weight
    }

    /**
     * 获取指定的public属性
     */
    @Test
    public void getAllPublicField() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            String name = field.getName();
            System.out.println(name);   //weight
        }
    }

    /**
     * 获取所有的属性
     */
    @Test
    public void getAllField() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String name = field.getName();
            System.out.print(name + " ");   //color weight
        }
    }

    /**
     * 获取指定的属性
     */
    @Test
    public void getOneField() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Field field = clazz.getDeclaredField("color");
        //    field.setAccessible(true);  //有没有 都能获取到，建议加上
        String name = field.getName();
        System.out.print(name + " ");   //color
    }

    /**
     * 获取public方法
     */
    @Test
    public void getPublicMethod() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Object o = clazz.newInstance();
        Method eat = clazz.getMethod("eat", String.class);
        eat.invoke(o, "rat");    //今晚cat吃了：rat
    }

    /**
     * 获取private方法
     */
    @Test
    public void getMethod() throws Exception {
        Class<?> clazz = Class.forName("com.zsc.reflect.Cat");
        Object o = clazz.newInstance();
        Method eat = clazz.getDeclaredMethod("sleep", Integer.class, String.class);
        eat.setAccessible(true);
        eat.invoke(o, 1,"red");    // 1个颜色是red的猫猫在睡觉
    }
}