Java 反射

反射

本文仅作为个人复习学习，反射 知识点使用。

本篇大部分内容结合了 CSDN博主「程序媛 泡泡」文章，如有喜欢本文内容的读者，请前往原作者页面支持原作者

https://blog.csdn.net/weixin_43884234/article/details/115056812

1.什么是反射？

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，也有称作“自省”。

反射非常强大，它甚至能直接操作程序的私有属性。我们前面学习都有一个概念，被private封装的资源只能类内部访问，外部是不行的，但是反射可以打破这种限制。

反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

2. 为什么需要反射

如果想创建对象,我们直接new User(); 不是很方便嘛，为什么要去通过反射创建对象呢？

这就涉及一个量的问题。如果需要项目规模很小，这个对象的创建不费劲还好说。

但，这不符合一般的设计思路。

举个例子，如果我们作为一个顾客去街边撸串，羊肉串、牛肉串、猪肉串，这些按理说等师傅烤好，咱们直接吃就可以。

new User(); 的过程：就是从羊、牛、猪的出生、饲养，到屠宰加工运输，师傅的烧烤处理，这些都交给咱们自己做，这显然忙不过来。有句话说的好，专业的事情交给专业的人去做，咱们负责吃就好了。

还有，师傅做好东西后，需要拿个盘子把这些东西装，这个盘子就是容器。

我们在后面的学习中,会学习框架,有一个框架Spring就是一个非常专业且功能强大的产品，它可以帮我们创建对象，管理对象。以后我无需手动new对象，直接从Spring提供的容器中的Beans获取即可。Beans底层其实就是一个Map<String,Object>，最终通过getBean(“user”)来获取。而这其中最核心的实现就是利用反射技术。

总结一句，类不是你创建的，是你同事或者直接是第三方公司，此时你要或得这个类的底层功能调用，就需要反射技术实现。有点抽象，别着急，我们做个案例，你就立马清晰。

3. 反射所需要的API

3.1 获取字节码对象

Class.forName(“类的全路径”);

类名.class

对象.getClass();

3.2 常用方法

获取包名 类名

class.getPackage().getName(); // 包名

class.getSingleName(); // 获取类名

class.getName(); //完整类名

获取成员变量定义信息

getFields(); // 获取所有公开的成员变量，包括继承变量

getDeclaredFields(); //获取本类定义的成员变量，包括私有，但不包括继承的变量

getField(变量名)

getDeclaredField(变量名)

获取构造方法定义信息

getConstructor(参数类型列表) //获取公开的构造方法

getConstructors() // 获取所有的公开的构造方法

getDeclaredConstructors() //获取所有的构造方法，包括私有方法

getDeclaredConstructor(int.class,String.class)

获取方法定义信息

getMethods() // 获取所有可见的方法，包括继承的方法

getMethod(方法名,参数类型列表)

getDeclaredMethods() // 获取本类定义的方法，包括私有，不包括继承的方法

getDeclaredMethod(方法名,int.class,String.class)

反射新建实例

class.newInstance(); //执行无参构造创建对象

class.newInstance(233,“海绵宝宝”); //执行含参构造创建对象

class.getConstructor(int.class,String.class) //获取构造方法

反射调用成员变量

class.getDeclaredField(变量名); //获取变量

class.setAccessible(true); //使私有成员允许访问

f.set(实例,值); //为指定实例的变量赋值，静态变量，第一参数给null

f.get(实例); //访问指定实例变量的值，静态变量t，第一参数给null

反射调用成员方法

Method m = class.getDeclaredMethod(方法名,参数类型列表);

m.setAccessible(true); //使私有方法允许被调用

m.invoke(实例,参数对象); //让指定的实例来执行该方法

4. 反射的应用

本篇大部分内容结合了 CSDN博主「程序媛 泡泡」文章，如有喜欢本文内容的读者，请前往原作者页面支持原作者

https://blog.csdn.net/weixin_43884234/article/details/115056812

4.1 创建：测试物料类

创建包：com.测试物料类反射

创建类：com.测试物料类反射.Student.java*

package com.测试物料类反射;
/*本类用于复习反射的物料类*/
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("今天大结局，放学后我要写1W行代码玩玩~");
    }
    public void sunDay(int n){
        System.out.println("国庆一共放"+n+"天");
    }
    //5.为了查看学生对象的具体属性与属性值，重写toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

4.2 练习：获取类对象

创建包：com.测试物料类反射.reflection

创建类：TestReflect.java

package com.测试物料类反射;

import org.junit.Test;

import java.lang.reflect.Method;
import java.util.Arrays;

/*本类用于反射的测试*/
public class TestReflect {
    //1.创建程序的入口函数main()--不用
    /*单元测试方法：是Java中最小的测试单位，使用灵活，推荐指数：5颗星
    * 语法要求：@Test + public + void + 没有参数
    * 注意：使用时需要导包：Add JUnit 4 library to the build path
    * 导包后的效果：import org.junit.Test
    * 执行方式：选中方法名前绿色的小三角，成功运行会有绿色的小对勾
    * */
    //2.通过单元测试方法，获取目标类Student对应的字节码对象
    @Test
    public void getClass() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class<?> class1 = Class.forName("cn.tedu.review.Student");
        Class<?> class2 = Student.class;
        Class<?> class3 = new Student().getClass();

        //打印的是Student类对应的字节码对象
        System.out.println(class1);//class cn.tedu.reflection.Student
        //获取当前字节码对象clazz1的名字
        System.out.println(class1.getName());//cn.tedu.reflection.Student
        //通过字节码对象，获取Student类的类名
        System.out.println(class2.getSimpleName());
        //通过字节码对象，获取Student类对应的包对象
        System.out.println(class3.getPackage());
        //通过字节码对象，先获取Student类对应的包对象，再获取这个包对象的名字
        System.out.println(class3.getPackage().getName());
    }

4.3 练习： 获取成员变量

package com.测试物料类反射;

import java.lang.reflect.Field;

import org.junit.Test;

/**本类用来测试反射*/
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.获取字节码对象
        Class<?> class = Class.forName("cn.tedu.review.Student");
        //2.通过字节码对象获取成员变量们
        Field[] fs = class.getFields();
        //3.遍历数组，获取每个成员变量的具体信息
        /*注意！目前成员变量的修饰符必须是public的才能获取到，不然，像默认修饰符也是获取不到的*/
        for(Field f : fs){
            System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
            System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
        }

    }
}

4.4 练习：通过字节码对象获取类的成员方法

package com.测试物料类反射;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
    //5.通过单元测试方法，获取Student类中的成员方法
    @Test
    public void getFunction() {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //2.通过字节码对象获取目标类中的成员方法们
        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));//打印方法参数的数组
        }

    }

4.5 练习：通过字节码对象获取类的构造方法

package com.测试物料类反射;

import java.lang.reflect.Constructor;
import java.util.Arrays;

import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
    //6.通过单元测试方法，获取Student类中的构造方法
    @Test
    public void getCons() {
        //1.获取字节码对象
        Class<?> clazz = new Student().getClass();
        //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));//打印参数类型
        }
    }

4.6 练习 ： 创建对象

import java.lang.reflect.Constructor;

import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
//7.通过单元测试方法，创建Student目标类的对象
    @Test
    public void getObject() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //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);
    }
}

4.7 熟悉API

自己创建类练习，获取类中所有的资源，熟悉反射中涉及的API

5. 暴力反射

指可以将程序中的私有的属性或者方法通过反射技术，暴力的获取到资源。

getDeclared* 等系列

---

本文仅作为个人复习学习，反射 知识点使用。

本篇大部分内容结合了 CSDN博主「程序媛 泡泡」文章，如有喜欢本文内容的读者，请前往原作者页面支持原作者

https://blog.csdn.net/weixin_43884234/article/details/115056812

---