JAVA的反射

做一个自我记录 

转至Java反射（通俗易懂）_有意悠悠的博客-CSDN博客Java基础之—反射（非常重要）_敬业小码哥的博客-CSDN博客 

反射使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）

1.反射

        Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。反射可以在运行时获取一个类的所有信息，（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

        要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象。

        反射就是把java类中的各种成分映射成一个个的Java对象。
        例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把一个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
        加载的时候：Class对象的由来是将 .class 文件读入内存，并为之创建一个Class对象。

        Class类

        Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）
        Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了。

        我们知道Spring框架可以帮我们创建和管理对象。需要对象时，我们无需自己手动new对象，直接从Spring提供的容器中的Beans获取即可。Beans底层其实就是一个Map，最终通过getBean(“user”)来获取。而这其中最核心的实现就是利用反射技术。   

        Bean

        1、Java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化；

        2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性；

        3、规律：凡是子类及带有方法或属性的类都要加上注册Bean到Spring IoC的注解；（@Component , @Repository , @ Controller , @Service , @Configration）

        4、把Bean理解为类的代理或代言人（实际上确实是通过反射、代理来实现的），这样它就能代表类拥有该拥有的东西了

        5、在Spring中，你标识一个@符号，那么Spring就会来看看，并且从这里拿到一个Bean（注册）或者给出一个Bean（使用）

2.API使用

我们可以完成以下操作：

1. 获取类的 Class 对象：可以使用 Class.forName("ClassName") 方法或者 .class 语法来获取表示类的 Class 对象。

2. 创建对象：使用 Class.newInstance() 或者 Constructor.newInstance() 方法来创建类的实例。

3. 获取类的方法：使用 getMethods()、getDeclaredMethods()、getMethod(String name, Class... parameterTypes) 等方法获取类的方法信息。

4. 调用方法：使用 Method.invoke(Object obj, Object... args) 方法调用类的方法。

5. 获取类的字段：使用 getFields()、getDeclaredFields()、getField(String name) 等方法获取类的字段信息。

6. 访问字段：使用 Field.get(Object obj) 和 Field.set(Object obj, Object value) 方法读取和修改类的字段值。

7. 动态代理：使用 Proxy.newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler handler) 方法创建接口的动态代理对象，并在代理对象上处理方法调用。

3.常用方法

可以通过Class类中的方法获取和查看该类中的方法和属性。 

//获取包名、类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名
 
//获取成员变量定义信息
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)
 
//获取构造方法定义信息
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)
 
//获取方法定义信息
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)
 
//反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(222,"韦小宝");//执行有参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法
 
//反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null
 
//反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法

 

3.1测试物料类

创建包: com.reflection
创建类: Student.java*

package com.review;
/*本类用于复习反射的物料类*/
public class Student {
    //1.定义成员变量
    private String name;
    public int age;
 
    //2.给被封装属性提供get与set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
 
    //3.生成本类的无参构造与全参构造
    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //4.提供本类的普通方法
    public void play(){
        System.out.println("不玩游戏，学Java！");
    }
    public void sunDay(int n){
        System.out.println("卷起来，没有假！");
    }
    //5.为了查看学生对象的具体属性与属性值，重写toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 

3.2获取类对象

由于经常使用的是第三种方法，所以以下使用第三种。

创建包: com.reflection
创建类: TestReflect.java

/*本类用于反射的测试*/
public class TestReflect {
    //1.可以创建程序的入口函数main()--此处不用
    //2.通过单元测试方法，获取目标类Student对应的字节码对象
    @Test
    public void getClazz() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class clazz1 = Class.forName("com.review.Student");
        Class clazz2 = Student.class;
        Class clazz3 = new Student().getClass();
 
        //打印的是Student类对应的字节码对象
        System.out.println(clazz1);//class com.reflection.Student
        //获取Student类对应的字节码对象clazz1的名字
        System.out.println(clazz1.getName());//com.reflection.Student
        //通过Student类对应的字节码对象，获取Student类的类名
        System.out.println(clazz1.getSimpleName());
        //通过Student类对应的字节码对象，获取Student类对应的包对象
        System.out.println(clazz1.getPackage());
        //通过Student类对应的字节码对象，先获取Student类对应的包对象，再获取这个包对象的名字
        System.out.println(clazz1.getPackage().getName());
    }
}

3.3 获取成员变量

/**本类用来测试反射*/
public class TestReflect {
	//3.通过单元测试方法练习引用类型数组的定义与遍历
    @Test
    public void getStu() {
        //1.创建Student类的3个对象
        Student s1 = new Student("张三", 3);
        Student s2 = new Student("李四", 4);
        Student s3 = new Student("王五", 5);
        //2.创建数组将刚刚的3个对象存入数组中
        Student[] s = {s1, s2, s3};
        //3.直接打印数组，查看数组中的元素
        System.out.println(Arrays.toString(s));
        //4.遍历学生数组，拿到每一个学生对象，做进一步的操作
        for (Student stu : s) {
            //System.out.println(stu);
            stu.play();//通过遍历到的对象，执行play()
            System.out.println(stu.age);//通过遍历到的对象，打印age属性
        }
    }
 
	//4.通过单元测试方法，获取Student类中的成员变量
    @Test
    public void getFie() throws ClassNotFoundException {
        //1.获取Student类对应的字节码对象
        Class clazz = Class.forName("com.review.Student");
        //2.通过Student类对应的字节码对象获取Student类中的成员变量们
        Field[] fs = clazz.getFields();
        //3.遍历数组，获取Student类中的每个成员变量的具体信息
        /*注意！目前成员变量的修饰符必须是public的才能获取到*/
        for(Field f : fs){
            System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
            System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
        }
 
    }
}

3.4通过字节码对象获取类的成员方法

/**本类用来测试反射*/
public class TestReflect {
    //5.通过单元测试方法，获取Student类中的成员方法
    @Test
    public void getFunction() {
        //1.获取Student类对应的字节码对象
        Class clazz = Class.forName("com.review.Student");
        //2.通过Student类对应的字节码对象获取Student类中的成员方法们
        Method[] ms = clazz.getMethods();
        //3.通过高效for循环遍历数组，拿到每一个方法对象
        for (Method m : ms) {
            System.out.println(m);//直接打印遍历到的方法对象
            System.out.println(m.getName());//通过方法对象获取方法名
            Class[] pt = m.getParameterTypes();//通过方法对象获取方法所有参数的数组
            System.out.println(Arrays.toString(pt));//打印方法参数的数组
        }
 
    }
}

3.5 通过字节码对象获取类的构造方法

/**本类用来测试反射*/
public class TestReflect {
    //6.通过单元测试方法，获取Student类中的构造方法
    @Test
    public void getCons() {
        //1.获取字节码对象
        Class clazz = Class.forName("com.review.Student");
        //2.通过字节码对象获取目标类Student的构造方法们
        Constructor[] cs = clazz.getConstructors();
        //3.通过高效for循环遍历数组
        for(Constructor c : cs){
            System.out.println(c.getName());//打印本轮遍历到的构造方法的名字
            Class[] pt = c.getParameterTypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
            System.out.println(Arrays.toString(pt));//打印参数类型
        }
    }
}

3.6 创建对象

/**本类用来测试反射*/
public class TestReflect {
//7.通过单元测试方法，创建Student目标类的对象
    @Test
    public void getObject() throws Exception {
        //1.获取字节码对象
        Class clazz = Class.forName("com.review.Student");
        
        //2.通过反射技术创建目标类的对象,注意抛出异常
        /*反射创建对象方案1：
            使用 目标类 的 无参构造 创建对象
        */
        Object o = clazz.newInstance();
        System.out.println(o);//这一步已经获取到了对象Student{name='null', age=0}
 
        /*反射创建对象方案2：
            使用 目标类 的 全参构造 创建对象
        * 思路：
        * 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
        * 2.通过刚刚获取到的构造函数对象创建Student目标类的对象，并且给对象的属性赋值
        * */
 
        //3.获取目标类中指定的全参构造
        Constructor c = clazz.getConstructor(String.class, int.class);
        //System.out.println(c);
 
        //4.通过获取到的构造函数：创建对象 + 给对象的属性赋值
        Object o2 = c.newInstance("赵六", 6);
        System.out.println(o2);
    }
}