• java反射全面复习

    https://blog.csdn.net/weixin_43884234/article/details/115056812?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162907817716780262531897%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=162907817716780262531897&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2blogtop_positive~default-2-115056812.pc_v2_rank_blog_default&utm_term=%E5%8F%8D%E5%B0%84&spm=1018.2226.3001.4450

    什么是反射

    反射是java的特征之一，它允许运行中的Java程序对自身进行检查
    反射十分强大，它甚至能直接操作程序的私有属性。
    我们在之前学习过，被private封装的资源只能内部访问，外部是不行的，但是这个规则会被反射打破
    反射可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以提供操作类的字段，方法，构造器等部分。

    为什么需要反射

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

    假设我们直接new User()的话，其中的细节步骤我们都需要自己把控，就像我们自己做菜，需要做到运输屠宰烹饪上菜，这是很麻烦的
    而我们使用反射，就可以做到直接调用，省略了很多步骤，让其中的内部细节交给更专业的人去做

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

    总结一句，类不是你创建的，是你同事或者直接是第三方公司，此时你要或得这个类的底层功能调用，就需要反射技术实现。

    反射需要用到的API

    class.forName(“类的全路径”)
    类名.class
    对象.getClass();

    常用方法

    获取包名 类名
    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(666,”海绵宝宝”);//执行含参构造创建对象
    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(实例,参数数据);//让指定实例来执行该方法

    反射的应用距离

    物料类

    创建包:cn.tedu.reflection
    创建类:Student.java*

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    练习：获取类对象

    创建包：cn.tedu.reflection
    创建类：TestReflect.java

    package cn.tedu.reflection;

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 getClazz() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class<?> clazz1 = Class.forName("cn.tedu.review.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();

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


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    练习：获取成员变量

    package cn.tedu.reflection;

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

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

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

    package cn.tedu.reflection;

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));//打印方法参数的数组
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

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

    package cn.tedu.reflection;

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));//打印参数类型
        }
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    练习 : 创建对象

    package cn.tedu.reflection;

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);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    5.1 创建 : 测试物料类

    创建包: cn.tedu. reflection
    创建类: Person.java*

    package cn.tedu.review;
/*本类用作暴力反射测试的物料类*/
public class Person {
    //1.提供私有属性
    private String name;
    private int age;

    //2.提供私有方法
    private void save(int n,String s){
        System.out.println("save()..."+n+s);
    }
    private void update(){
        System.out.println("update()...");
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    练习 : 创建测试类

    创建包: cn.tedu. reflection
    创建类: TestReflect2.java

    package tedu.reflection;

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/*本类用于测试暴力反射*/
public class TestReflect2 {
   /*1.通过暴力反射获取与操作属性*/
    @Test
    public void getFie2() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性，传入的是属性名，注意抛出异常
        Field field = clazz.getDeclaredField("name");
        //3.根据刚刚获取到的属性对象，查看属性的信息
        System.out.println(field);//直接打印获取到的字段对象
        System.out.println(field.getType().getName());//java.lang.String
        System.out.println(field.getType());//class java.lang.String

        //4.设置属性的值
        //4.1 需要指定到底是给哪个对象的name属性设置值，没有对象就创建对象
        Object obj = clazz.newInstance();//触发无参构造利用反射创建对象

        //4.2暴力反射，需要设置私有可见权限！！！
        field.setAccessible(true);

        //4.3通过字段对象给刚刚创建好的对象obj设置属性值为海绵宝宝
        //field就是我们刚刚获取的name属性
        //set(m,n)--m是给哪个对象的name属性设置值，n是设置的值是什么
        field.set(obj,"海绵宝宝");
        //4.4 打印查看刚刚设置的属性值
        //field.get(m)--field代表的就是Person类的name属性，m是查看哪个对象的这个属性值
        System.out.println(field.get(obj));
    }

    //2.定义单元测试方法，利用暴力反射操作Person类中的私有属性age【巩固练习】
    @Test
    public void getFie3() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性对象
        Field f = clazz.getDeclaredField("age");
        //3.根据获取到的属性对象，查看相关信息，比如属性的类型
        System.out.println(f.getType().getName());
        //4.操作：设置属性的值：一共需要三个元素：给哪个对象【1】的哪个属性【2】设置一个什么值【3】
        //4.1 需要先指定给哪个对象的这个age属性设置值
        Object obj = clazz.newInstance();
        //4.2 在给属性设置值之前，需要设置权限私有可见，否则报错！
        f.setAccessible(true);
        //4.3通过刚刚获取到的age属性对象，给obj对象设置值
        f.set(obj,17);
        //4.4打印查看刚刚的属性值是否设置成功
        System.out.println(f.get(obj));
    }
    /*3.单元测试2：暴力反射获取和设置私有方法*/
    @Test
    public void getFunction() throws Exception {
        //1.获取Class字节码对象
        Class<?> clazz = Person.class;
        //2.通过暴力反射获取私有方法
        /*getDeclaredMethod(m,x,y,z...)
        * m:要获取的方法名
        * x,y,z...可变参数，是这个方法的参数类型，但注意要加“.class”
        * */
        Method method = clazz.getDeclaredMethod("save",int.class,String.class);
        //3.1没有对象就通过反射的方式创建对象
        Object obj = clazz.newInstance();
        //3.2 想要执行私有方法，也需要先设置私有可见
        method.setAccessible(true);
        /*invoke(o,x,y,z...),表示通过反射技术执行方法
        * o :要执行的是哪个对象的方法
        * x,y,z...:执行这个方法【method对象代表的之前获取到的save()】时需要传入的参数
        * */
        //3.3 通过反射技术invoke()，执行目标对象obj的目标方法method【save()】
        //save()被调用时传入的参数是100,"海绵宝宝"
        method.invoke(obj,100,"海绵宝宝");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
  • 相关阅读:
    仿抖音短视频用户业务模块----完成用户信息增删改查并通过接口文档联调（模拟工作环境）
    JNA java调用dll
    【华为OD机试真题 python】 转骰子【2022 Q4 | 200分】
    建站软件WordPress和phpcmsv9体验
    Pulsar-Pulsar 之 Functions
    Apache SeaTunnel Web 功能正式发布！
    Proxmox VE 近期有ARM 版本发布么？
    《CTFshow-Web入门》09. Web 81~90
    【无标题】接口测试遇到的典型bug纪录
    Haircut（剪发）
  • 原文地址：https://blog.csdn.net/weixin_43847969/article/details/125555793