反射机制:反射

介绍

在JAVA中，我们只要有一个类，就可以创建对象。那如果给定一个对象，是否能反过来获取类的信息呢？

JAVA反射机制是在运行状态中，对于任意一个类，都能够通过对象等信息知道这个类的所有属性和方法。在程序编译时，不确定哪个类被加载，而在程序运行时才加载、探知、使用。

反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。

因为反射获取的是类的信息，那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象，获取到的类其实也是以对象的形式体现的，叫字节码对象，用Class类来表示。获取到字节码对象之后，再通过字节码对象就可以获取到类的组成成分了，这些组成成分其实也是对象，其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示，每一个构造器用Constructor类的对象来表示。

获取类信息的三种方法

1. 通过对象名获取类信息；
2. 通过类名获取类信息；
3. 通过路径获取类信息；

反射获取构造方法并使用【应用】

Class类获取构造方法对象的方法

import java.lang.reflect.Constructor;

public class Demo01 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        Class<?> clz = Class.forName("com.heima.test3.Student");


        //method01(clz);
        //method02(clz);
        //method03(clz);

        method04(clz);

    }

    //获取单个的私有或者公有的构造 根据参数获取
    private static void method04(Class<?> clz) throws NoSuchMethodException {
        //private com.heima.test3.Student(java.lang.String)
        Constructor<?> c1 = clz.getDeclaredConstructor(String.class);
        //public com.heima.test3.Student(java.lang.String,int)
        System.out.println(c1);
    }

    //获取单个的公有的构造 根据参数获取
    private static void method03(Class<?> clz) throws NoSuchMethodException {
        //获取单个的公有的构造 根据参数获取
        Constructor<?> c = clz.getConstructor(String.class, int.class);
        //public com.heima.test3.Student(java.lang.String,int)
        System.out.println(c);
    }

    //获取所有的(包括私有的)构造方法
    private static void method02(Class<?> clz) {
        //private com.heima.test3.Student(java.lang.String)
        //public com.heima.test3.Student()
        //public com.heima.test3.Student(java.lang.String,int)
        Constructor<?>[] declaredC = clz.getDeclaredConstructors();
        for (Constructor<?> c : declaredC) {
            System.out.println(c);
        }
    }

    //获取所有公共构造方法
    private static void method01(Class<?> clz) {
        //获取所有公共构造方法
        Constructor<?>[] constructors = clz.getConstructors();
        //public com.heima.test3.Student()
        //public com.heima.test3.Student(java.lang.String,int)
        for (Constructor<?> c : constructors) {
            System.out.println(c);
        }
    }
}

Constructor类用于创建对象的方法

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c1 = Class.forName("com.heima.test3.Student");

        //获取公有的指定参数的构造方法
        Constructor constructor1 = c1.getConstructor();
        System.out.println(constructor1);
        //用构造方法的newInstance 来创建对象
        Student s1 = (Student) constructor1.newInstance();
        System.out.println(s1);

        System.out.println("--------------------------------------------");
        //获取公有的指定参数的构造方法 参数类型 是String和int
        Constructor constructor2 = c1.getConstructor(String.class, int.class);
        System.out.println(constructor2);
        //用构造方法的newInstance 来创建对象,传入参数"张三", 18
        Student s2 = (Student) constructor2.newInstance("张三", 18);
        System.out.println(s2);


        //获取私有的指定的构造方法  参数类型是String
        System.out.println("--------------------------------------------");
        Constructor constructor3 = c1.getDeclaredConstructor(String.class);
        System.out.println(constructor3);
        //设置私有构造为可以访问的  暴力反射
        constructor3.setAccessible(true);
        //用构造方法的newInstance 来创建对象,传入参数 lisi
        Student s3 = (Student) constructor3.newInstance("lisi");
        System.out.println(s3);

        System.out.println("--------------直接用类newInstance 被淘汰的方式-----------------------");
        Student s4 = (Student) c1.newInstance();//直接用类对象.newInstance 被淘汰的方式
        System.out.println(s4);
    }

小结

- 获取class对象

• 三种方式: Class.forName(“全类名”), 类名.class, 对象名.getClass()

- 获取里面的构造方法对象

• getConstructor (Class<?>... parameterTypes)
• getDeclaredConstructor (Class<?>... parameterTypes)

- 如果是public的，直接创建对象

• newInstance(Object... initargs)

- 如果是非public的，需要临时取消检查，然后再创建对象

• setAccessible(boolean) 暴力反射

反射获取成员变量并使用【应用】

Student代码

public class Student {
    public String name;
    public int age;
    public String gender;
    private int money = 300;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", money=" + money +
                '}';
    }
}

测试代码

Class c1 = Class.forName("com.heima.test4.Student");

//返回所有公共成员变量对象的数组
Field[] fs1 = c1.getFields();
for (Field f : fs1) {
    System.out.println(f);
}
System.out.println("-----------------------------------");
//返回所有成员变量(包含公共的和私有的)对象的数组
Field[] fs2 = c1.getDeclaredFields();
for (Field f : fs2) {
    System.out.println(f);
}

//获取公共的 指定的变量名字的的对象
Field fieldName = c1.getField("name");
System.out.println(fieldName);

//获取公共的 指定的变量名字的的对象
Field fieldage = c1.getField("age");
System.out.println(fieldage);

//获取公共的 指定的变量名字的的对象
Field fieldgender = c1.getField("gender");
System.out.println(fieldgender);


//获取私有的 指定的变量名字的对象
Field fieldmoney = c1.getDeclaredField("money");
System.out.println(fieldmoney);

Field类用于给成员变量赋值的方法

public class Demo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Student的类对象
        Class<?> clz = Class.forName("com.heima.test4.Student");

        //获取构造方法
        Constructor<?> constructor = clz.getConstructor();

        //创建一个学生对象
        Object o = constructor.newInstance();


        //获取name属性的Field对象
        Field fName = clz.getField("name");

        //获取money属性的Field对象
        Field fMoney = clz.getDeclaredField("money");


        //给name赋值  参1是要赋值的对象 参2是具体的值
        fName.set(o, "zs");
        System.out.println(o);

        //给money赋值
        fMoney.setAccessible(true);//设置私有变量可以访问
        fMoney.set(o, 200);//给money赋值
        System.out.println(o);

        //获取值
        System.out.println(fName.get(o));
        System.out.println(fMoney.get(o));

    }
}

反射获取成员方法并使用【应用】

Class类获取成员方法对象的方法

public class Student {

    //私有的，无参无返回值
    private void show() {
        System.out.println("私有的show方法，无参无返回值");
    }

    //公共的，无参无返回值
    public void function1() {
        System.out.println("function1方法，无参无返回值");
    }

    //公共的，有参无返回值
    public void function2(String name) {
        System.out.println("function2方法，有参无返回值,参数为" + name);
    }

    //公共的，无参有返回值
    public String function3() {
        System.out.println("function3方法，无参有返回值");
        return "aaa";
    }

    //公共的，有参有返回值
    public String function4(String name) {
        System.out.println("function4方法，有参有返回值,参数为" + name);
        return "aaa";
    }
}
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //method1();
        //method2();
        //method3();
        //method4();
        //method5();
    }

    private static void method1() throws ClassNotFoundException {
        //        Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
        //1.获取class对象
        Class clazz = Class.forName("com.heima.test5.Student");
        //2.获取成员方法对象
        Method[] methods = clazz.getMethods();
        //3.遍历
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void method2() throws ClassNotFoundException {
        //        Method[] getDeclaredMethods()：
//                                返回所有成员方法对象的数组，不包括继承的
        //1.获取class对象
        Class clazz = Class.forName("com.heima.test5.Student");

        //2.获取Method对象
        Method[] methods = clazz.getDeclaredMethods();
        //3.遍历一下数组
        for (Method method : methods) {
            System.out.println(method);
        }
    }

    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        //        Method getMethod(String name, Class<?>... parameterTypes) ：
//                                返回单个公共成员方法对象
        //1.获取class对象
        Class clazz = Class.forName("com.heima.test5.Student");
        //2.获取成员方法function1
        Method method1 = clazz.getMethod("function1");
        //3.打印一下
        System.out.println(method1);
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        //1.获取class对象
        Class clazz = Class.forName("com.heima.test5.Student");
        //2.获取一个有形参的方法function2
        Method method = clazz.getMethod("function2", String.class);
        //3.打印一下
        System.out.println(method);
    }

    private static void method5() throws ClassNotFoundException, NoSuchMethodException {
        //        Method getDeclaredMethod(String name, Class<?>... parameterTypes)：
//                                返回单个成员方法对象
        //1.获取class对象
        Class clazz = Class.forName("com.heima.test5.Student");
        //2.获取一个成员方法show
        Method method = clazz.getDeclaredMethod("show");
        //3.打印一下
        System.out.println(method);
    }
}

Method类用于执行方法的方法

参数一: 用obj对象调用该方法

参数二: 调用方法的传递的参数(如果没有就不写)

返回值: 方法的返回值(如果没有就不写)

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    
    Class<?> clz = Class.forName("com.heima.test5.Student");

    //创建一个实例对象
    Object o = clz.getConstructor().newInstance();

    Method mFunc1 = clz.getMethod("function1");
    Method mFunc2 = clz.getMethod("function2", String.class);
    Method mFunc3 = clz.getMethod("function3");
    Method mFunc4 = clz.getMethod("function4", String.class);

    Method mShow = clz.getDeclaredMethod("show");

    //无参无返回值方法调用
    mFunc1.invoke(o);
    //有参无返回值方法调用
    mFunc2.invoke(o, "aaa");
    //无参有返回值方法调用
    System.out.println(mFunc3.invoke(o));
    //有参有返回值方法调用
    System.out.println(mFunc4.invoke(o, "zzzz"));


    //mShow设置为私有可以访问
    mShow.setAccessible(true);
    //调用方法show
    mShow.invoke(o);
}