反射

反射是为学习框架的底层源码做准备。

定义：反射就是加载类，并允许已编程的方式解剖类中的各种成分（成员变量、方法、构造器等）。

1.获取Class的三种方式

首先要创建一个Student类

public class test {
    public static void main(String[] args) throws Exception {
        Class c1 = Student.class;
        System.out.println(c1.getName()); // 全类名
        System.out.println(c1.getSimpleName()); // 简名: Student

        Class c2 = Class.forName("com.d2_reflect.Student");
        System.out.println(c1 == c2);

        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3 == c2);
    }
}

2.获取类的构造器

下面代码可以拿到cat类的构造器

public class test {
    @Test
    public void testGetConstructors() {
        // 1. 反射第一步，必须先得到这个类的Class对象
        Class c = Cat.class;

        // 2. 获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors();

        // 3. 遍历数组中的每个构造器对象
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + " ---> " + constructor.getParameterCount());
        }
    }
            @Test
        public void testGetConstructor() throws Exception {
            // 1. 反射第一步，必须先得到这个类的Class对象
            Class c = Cat.class;
        
            // 2. 获取某个构造器，无参数构造器
            Constructor constructor = c.getDeclaredConstructor();
            System.out.println(constructor.getName() + " ---> " + constructor.getParameterCount());
        
            // 3. 获取有参数构造器
            Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);//后边加上参数类型
            System.out.println(constructor2.getName() + " ---> " + constructor2.getParameterCount());
}

}

public class test {

           @Test
        public void testGetConstructor() throws Exception {
            // 1. 反射第一步，必须先得到这个类的Class对象
            Class c = Cat.class;

            // 2. 获取类的某个构造器，无参数构造器
            Constructor constructor1 = c.getDeclaredConstructor();
            System.out.println(constructor1.getName() + " ---> " + constructor1.getParameterCount());

            constructor1.setAccessible(true); // 取消检查访问权限，暴力访问
            Cat cat = (Cat) constructor1.newInstance();
            System.out.println(cat);
            
            
            
            // 3. 获取有参数构造器
            Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);
            System.out.println(constructor2.getName() + " ---> " + constructor2.getParameterCount());
            
            constructor2.setAccessible(true); // 取消检查访问权限
            Cat cat2 = (Cat) constructor2.newInstance("叮当猫", 3);
            System.out.println(cat2);

}

}

3.获取类的成员变量

public class test {

    @Test
public void testGetFields() throws Exception {
    // 1. 反射第一步，必须先得到类的Class对象
    Class c = Cat.class;

    // 2. 获取类的全部成员变量
    Field[] fields = c.getDeclaredFields();

    // 3. 遍历这个成员变量数组
    for (Field field : fields) {
        System.out.println(field.getName() + " ---> " + field.getType());
    }

    // 4. 定位某个成员变量
    Field fName = c.getDeclaredField("name");
    System.out.println(fName.getName() + " ---> " + fName.getType());

    Field fAge = c.getDeclaredField("age");
    System.out.println(fAge.getName() + " ---> " + fAge.getType());
}


}

// 赋值
Cat cat = new Cat();
fName.setAccessible(true); // 取消访问控制权限
fName.set(cat, "卡菲猫");
System.out.println(cat);

// 取值
String name = (String) fName.get(cat);
System.out.println(name);

4.获取类的成员方法

public class test {

    @Test
    public void testGetFields() throws Exception {
        // 1. 反射第一步，必须先得到类的Class对象
       // 1. 反射第一步，先得到Class对象。
    Class c = Cat.class;

    // 2. 获取类的全部成员方法。
    Method[] methods = c.getDeclaredMethods();

    // 3. 遍历这个数组中的每个方法对象。
    for (Method method : methods) {
        System.out.println(method.getName() + " ---> "
            + method.getParameterCount() + " ---> "
            + method.getReturnType());
    }

    // 4. 获取某个方法对象
    Method run = c.getDeclaredMethod("run"); // 拿run方法，无参数。
    System.out.println(run.getName() + " ---> "
        + run.getParameterCount() + " ---> "
        + run.getReturnType());

    Method eat = c.getDeclaredMethod("eat", String.class);
    System.out.println(eat.getName() + " ---> "
        + eat.getParameterCount() + " ---> "
        + eat.getReturnType());


    }


}

Cat cat = new Cat();
run.setAccessible(true); // 取消检查访问权限
Object rs = run.invoke(cat); // 调用无参数的run方法，用cat对象触发调用
System.out.println(rs);

eat.setAccessible(true); // 取消检查访问权限
String rs2 = (String) eat.invoke(cat, "鱼儿"); // 调用有参数的eat方法
System.out.println(rs2);

反射的作用及应用场景

基本作用：可以得到一个类的全部成分然后操作。

可以破快封装性

最重要：适合做Java的框架，基本数，主流的框架会基于反射设计出一些通用的功能。

public class test {
    @Test
    public void save() throws Exception {
        Student s1 = new Student("马吴彦祖", 45, '男', 185.3, "篮球,冰球,游泳");
        Teacher t1 = new Teacher("珊姐", 999.9);

        // 把任意对象的字段名和其对应的值等信息，保存到文件中去。
        ObjectFrame.saveObject(s1);
        ObjectFrame.saveObject(t1);
    }
}

框架

public class ObjectFrame {
    // 目标: 保存任意对象的字段和其数据到文件中去
    public static void saveObject(Object obj) throws Exception {
        PrintStream ps = new PrintStream(new FileOutputStream("junit-output.txt", true));
        
        // obj是任意对象，剥夺有多少个字段需要保存。
        Class c = obj.getClass();
        String cName = c.getSimpleName();
        ps.println("=============== " + cName + " ===============");

        // 2. 从这个类中提取出的全部成员变量
        Field[] fields = c.getDeclaredFields();

        // 3. 遍历成员变量
        for (Field field : fields) {
            // 4. 获取变量的名字
            String name = field.getName();

            // 5. 突破javabean规范进行直接访问
            field.setAccessible(true); // 取消检查访问控制
            String value = field.get(obj) + "";
            ps.println(name + " = " + value);
        }
        ps.close();
    }
}

两个学生和老师的构造器自己写一下。