Java反射机制

概念：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。简单来说，反射机制指的是程序在运行时能够获取自身的信息。在 Java 中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。

类的加载机制：

new 对象()

1.JVM加载对象.class文件

        1.1JVM在硬盘找对象.class文件并读取到内存中

        1.2JVM自动创建一个class对象，一个文件会产生一个对象

2.根据这个class类和对象然后动态的产生对象类的对象

反射机制：

①类的加载   

public class DemoA {
    public static void a() throws Exception {
        //加载指定类
        //最常用的，通过路径获取到类
        Class c1 = Class.forName("fanshe.Person");
        System.out.println(c1);
        //通过类名来获取到类
        Class c2 = Person.class;
        System.out.println(c2);
        //通过对象来逆推出类的对象
        Person person = new Person();
        Class c3 = person.getClass();
        System.out.println(c3);
        //特殊的，只有8个类型的封转类，可以获取到对应的原始类型
        Class c4 = Integer.TYPE;
        System.out.println(c4);
        Class c5 = Integer.class;
        System.out.println(c5);
    }

    //重点
    public static void b() throws Exception {
        Class c1 = Class.forName("fanshe.Person");
        Class c2 = Class.forName("fanshe.Person");//不会重复产生一个class对象
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c1 == c2);
    }

    public static void main(String[] args) throws Exception {
        b();
    }
}

  

②构造器和对象 

public class DemoB {
    public static void main(String[] args) throws Exception {
        //获取到了类
        Class c1 = Class.forName("fanshe.Person");
        //获取到了构造器、
        Constructor[] constructors = c1.getDeclaredConstructors();//获取到所有定义的构造器
        System.out.println(constructors.length);
        Constructor constructor1 = c1.getConstructor();//获取到指定构造器 无参构造器
        System.out.println(constructor1);
        Class[] xin1 = {Integer.class};//获取到指定形式参数列表
        Constructor constructor2 = c1.getDeclaredConstructor(xin1);//获取到有一个int参数构造器
        System.out.println(constructor2);
        Class[] xin2 = {Integer.class, String.class};
        Constructor constructor3 = c1.getDeclaredConstructor(xin2);//获取到2个参数构造器 int String
        System.out.println(constructor3);
        Class[] xin3 = {String.class};
        Constructor constructor4 = c1.getDeclaredConstructor(xin3);//获取到1个参数构造器 String参数类型
        System.out.println(constructor4);
        System.out.println("---------------------------------------");
        //通过构造器初始化对象
        Object o1 = constructor1.newInstance();//产生了指定类型的对象并通过指定构造器初始化
        System.out.println(o1);
        Object[] sj1 = {10};
        Object o2 = constructor2.newInstance(sj1);
        System.out.println(o2);
        Object[] sj2 = {10, "张三"};
        Object o3 = constructor3.newInstance(sj2);
        System.out.println(o3);
        //设置私有内容可以被访问
        constructor4.setAccessible(true);
        Object o4 = constructor4.newInstance("李四");
        System.out.println(o4);

    }

}

  

③属性（成员变量） 

public class DemoC {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("fanshe.Student");
        //产生当前类的对象
        Object obj = c.getDeclaredConstructor().newInstance();
        //获取到属性
        Field[] fields1 = c.getDeclaredFields();//获取到定义的所有属性
        Field[] fields2 = c.getFields();//获取所有的非私有属性
        for (Field f : fields1) {
            System.out.println(f.getName());//输出属性名
        }
        System.out.println("----------------------------------------");
        for (Field f : fields2) {
            System.out.println(f.getName());//输出属性名
        }
        System.out.println("----------------------------------------");
        Field field1 = c.getDeclaredField("d");//通过名称在定义的范围里寻找
        Field field2 = c.getField("b");//通过名称在非私有的范围里找
        System.out.println(field1);
        System.out.println(field2);
        //Field类的常用方法
        String stu = field1.getName();//获取属性名
        Class c1 = field1.getType();//获取数据类型
        //给属性赋值
        field1.set(obj, "张三");//obj：对象  张三：赋的值
        Object ob = field1.get(obj);//获取赋的值
        System.out.println(ob);
        //操作私有属性
        Field field3 = c.getDeclaredField("c");
        field3.setAccessible(true);
        field3.set(obj, 2);
        System.out.println(field3.get(obj));
    }
}

 

④方法

public class DemoD {
    public static void main(String[] args) throws Exception {
        //获取到类
        Class c1 = Class.forName("fanshe.Student");
        //获取到对象、
        Object obj = c1.getDeclaredConstructor().newInstance();
        //获取到相应的方法
        Method[] methods1 = c1.getMethods();
        Method[] methods = c1.getDeclaredMethods();
        Method method1 = c1.getMethod("c", Integer.TYPE);//2件事情：方法名，形式参数列表
        Method method2 = c1.getDeclaredMethod("d", Integer.TYPE, String.class);
        Method method3 = c1.getDeclaredMethod("e");
        Method method41 = c1.getDeclaredMethod("f");
        Method method42 = c1.getDeclaredMethod("f", Integer.TYPE);
        //如何调用这些方法
        //调用有参数和私有的方法
        method1.invoke(obj, 1);
        method2.setAccessible(true);
        method2.invoke(obj, 1, "李四");
        System.out.println("-------------------------------------------");
        //调用有返回结果的方法
        Object result = method3.invoke(obj);
        System.out.println(result);
        //重载方法的调用
        method41.invoke(obj);
        method42.invoke(obj, 2);
    }
}

 案例：通过反射的方式进行赋值

@Data
public class Users {
    private Integer id;
    private String name;
    private Character sex;
    private Integer age;
    private String address;
}


public class Demo {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入id：");
        int id = scanner.nextInt();
        System.out.print("请输入姓名：");
        String name = scanner.next();
        System.out.print("请输入性别：");
        char sex = scanner.next().charAt(0);
        System.out.print("请输入年龄：");
        int age = scanner.nextInt();
        System.out.print("请输入地址：");
        String address = scanner.next();
        //通过new对象的方式进行赋值
        Users users = new Users();
        users.setId(id);
        users.setName(name);
        users.setSex(sex);
        users.setAge(age);
        users.setAddress(address);
        System.out.println(users);
        //通过反射的方式进行赋值
        Class c = Class.forName("fanshe.users.Users");
        Object obj = c.getDeclaredConstructor().newInstance();
        Field[] field = c.getDeclaredFields();
        for (Field f : field) {
            //通过调用属性的set方法来实现的
            String fieldName = f.getName();//获取属性的名字
            String methodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);//方法名
            System.out.println(fieldName + "对应的set方法：" + methodName);
            Class parameterType = f.getType();//数据类型
            Method method = c.getDeclaredMethod(methodName, parameterType);//获取到方法
            if (fieldName.equals("id")) {
                method.invoke(obj, id);
            } else if (fieldName.equals("name")) {
                method.invoke(obj, name);
            } else if (fieldName.equals("sex")) {
                method.invoke(obj, sex);
            } else if (fieldName.equals("age")) {
                method.invoke(obj, age);
            } else if (fieldName.equals("address")) {
                method.invoke(obj, address);
            } else {
                System.out.println("错误");
            }
        }
        System.out.println(obj);
    }
}