Java中的反射（20分钟带你了解Java中的反射）

最新推荐文章于 2023-06-10 09:00:00 发布
最新推荐文章于 2023-06-10 09:00:00 发布
阅读量2.8k 收藏 24
点赞数 4
分类专栏： Java 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/manqishizhizhu/article/details/123239829
版权

类加载器

1、类加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过：类的加载、类的连接、类的初始化这三个步骤来对类进行初始化。如果不出现意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤称为：类加载或类的初始化。

类的加载

  • 就是指将 class文件读入内存，并为之创建一个 java.lang.Class 对象；
  • 任何类被使用时，系统都会为之建立一个 java.lang.Class 对象。

类的连接

  • 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其他类协调一致；
  • 准备阶段：负责为类的类变量分配内存，并设置默认初始值；
  • 解析阶段：将类的二进制数据中的符号引用替换为直接引用。

类的初始化

  • 在该阶段，主要就是对类变量进行初始化
类的初始化步骤：
1. 假如类还未被加载和连接，则程序先加载并连接该类；
2. 假如该类的直接父类还未被初始化，则先初始化其直接父类；
3. 假如类中有初始化语句，则系统依次执行这些初始化语句。

注意：在执行第2步的时候，系统对直接父类的初始化步骤也遵循初始化步骤1~3
所以JVM最先初始化的总是Object类

类的初始化时机：
创建类的实例；
调用类的类方法(静态方法)；
访问类或者接口的类变量，或者为该类变量赋值；
调用反射方式来强制创建某个类或接口对应的 java.lang.Class 对象；
初始化某个类的子类；
直接调用 java.exe命令运行某个主类。

2、类加载器

类加载器的作用

作用：
负责将 .class 文件加载到内存，并为之生成对应的 java.lang.Class 对象

反射

1、反射概述

现有 Student和Teacher两个类
这两个类若想使用，首先就得通过类加载器加载对应的 .class 文件到内存，每一个 .class 文件中都应该包含：成员变量、构造方法、成员方法等信息。而每一个 .class 文件都包含这些信息，也就是说所有的 .class文件都有这样的信息，那么我们有没有一个类来描述这些信息呢？肯定是有的，这个类就是 Class类，所以这个类就是所有 .class对象所对应的类型。我们通过Class类里面的对象去使用这些成员变量、成员方法等，而不再通过 Student、Teacher去直接使用。

总结：
Java反射机制是指在运行时去获取一个类的变量和方法信息，然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大地增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍可以扩展。

2、开发步骤

1、创建 Student.java

package test;

/**
 * @author Zeng Li
 * @version 1.0
 * @date 2022/3/2 0:30
 */
public class Student {

    // 一个私有、一个默认、一个公共
    private String name;
    int age;
    public String address;


    public Student() {

    }
    private Student(String name) {
        this.name = name;
    }
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void method1() {
        System.out.println("method1()执行了...");
    }

    public void method2(String s) {
        System.out.println("method2()：" + s);
    }

    public String method3(String s, int i) {
        return s + "," + i;
    }

    private void function() {
        System.out.println("function()执行了...");
    }



    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

2、获取Class类的对象

我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象

@Test
public void test() throws ClassNotFoundException {
    // 第一种方式获取Class对象
    Class<Student> s1 = Student.class;
    System.out.println(s1);
    Class<Student> s2 = Student.class;
    // 一个类在内存中只有一个字节码文件对象
    System.out.println(s1 == s2); //true

    // 第二种方式获取Class对象
    Student student = new Student();
    Class<? extends Student> s3 = student.getClass();
    System.out.println(s1 == s3); //true

    // 第三种方式获取Class对象
    Class<?> s4 = Class.forName("test.Student"); // 推荐写法
    System.out.println(s1 == s4); //true
}

3、反射获取构造方法

  • 方法1

    aClass.getConstructors();
// 返回一个包含 Constructor对象的数组，反映由该Class对象表示的类的所有 公共 构造函数

    测试

    @Test
public void test1() throws ClassNotFoundException {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    // 返回一个包含 Constructor对象的数组，反映由该Class对象表示的类的所有 公共 构造函数
    Constructor<?>[] c1 = aClass.getConstructors();
    for (Constructor<?> constructor : c1) {
        System.out.println(constructor);
    }
}

    image-20220302005543281

  • 方法2

     aClass.getDeclaredConstructors()
// 返回由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组

    @Test
public void test1() throws ClassNotFoundException {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    // aClass.getDeclaredConstructors()
    // 返回由该 Class对象表示的类声明的所有构造函数的 Constructor对象的数组
    Constructor<?>[] c1 = aClass.getDeclaredConstructors();
    for (Constructor<?> constructor : c1) {
        System.out.println(constructor);
    }
}

    image-20220302005853926

  • 方法3

    aClass.getConstructor()
// 返回一个 Constructor对象，该对象反映由该Class对象表示的类的指定 公共 构造函数
// 参数：要获取的构造方法的参数的个数及数据类型对应的字节码文件对象
constructor.newInstance();

    @Test
public void test1() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    // aClass.getConstructor()
    // 返回一个 Constructor对象，该对象反映由该Class对象表示的类的指定 公共 构造函数
    // 参数：要获取的构造方法的参数的个数及数据类型对应的字节码文件对象
    Constructor<?> constructor = aClass.getConstructor();
    // 通过构造方法对象里面的对象来创建对象，这才叫反射
    // 使用此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例。
    Object obj = constructor.newInstance();//获取无参构造函数
    System.out.println(obj);
}

    image-20220302010821642

  • 测试：访问 公共 的带参构造方法

    @Test
public void test2() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    //  public Student(String name, int age, String address) {
    // 获取单个的构造方法
    Constructor<?> constructor = aClass.getConstructor(String.class,int.class,String.class);
    // 通过构造方法对象里面的对象来创建对象，这才叫反射
    // 使用此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例。
    Object obj = constructor.newInstance("rabbit",22,"上海");
    System.out.println(obj);
}

    image-20220302011733081

  • 测试：访问 私有的带参的构造方法

    @Test
public void test3() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    //  public Student(String name, int age, String address) {
    // 获取单个的构造方法
    Constructor<?> constructor = aClass.getDeclaredConstructor(String.class);
    // 我们不能通过私有的构造方法创建对象，但在反射中却可以，需要进行暴力反射
    // 取消访问检查
    constructor.setAccessible(true);
    Object obj = constructor.newInstance("rabbit");
    System.out.println(obj);
}

    image-20220302162002837

4、反射获取成员变量并使用

  • 方式一：Field[] getFields();

    Field[] getFields();
//返回一个包含Field对象的数组，Field对象反映由该Class对象表示的类或接口的所有可访问的 公共 的成员变量

    @Test
public void test4() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Field[] fields = aClass.getFields();
    for (Field field : fields) {
        System.out.println(field);
    }
}

    image-20220302164350338

  • 方式二：aClass.getDeclaredFields();

    Field[] getDeclaredFields();
//返回一个包含Field对象的数组，Field对象反映由该Class对象表示的类或接口的所有成员变量

    @Test
public void test5() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Field[] fields = aClass.getDeclaredFields();
    for (Field field : fields) {
        System.out.println(field);
    }
}

    image-20220302164503344

  • 方法三：为成员变量赋值

    	Field getField(String name);
// 返回一个 Field对象，该对象反映由该Class对象表示的类或接口的指定 公共 成员字段

    /**
 * Field getField(String name);
 * 返回一个 Field对象，该对象反映由该Class对象表示的类或接口的指定 公共 成员字段
 * 步骤：
 *      1. 首先获取Class对象；
 *      2. 按照Class对象按照指定的成员变量得到成员变量对象；
 *      3. 最后通过成员变量对象调用set(obj1,obj2)方法
 *      4. field.set(obj1,obj2)：为obj1对象的成员变量field赋值为obj2
 */
@Test
public void test6() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Field addressField = aClass.getDeclaredField("address");
    // 通过反射，为成员变量赋值：student.address = "上海"
    // 获取无参构造方法构造对象
    Constructor<?> constructor = aClass.getConstructor();
    Object obj = constructor.newInstance();
    // 给obj的成员变量addressField赋值为上海
    addressField.set(obj,"上海");
    System.out.println(obj);
}

    image-20220302165912447

  • 练习

    /**
 * 练习：
 * Student student = new Student();
 * student.name = "rabbit"
 * student.age = 22
 * student.address = "上海"
 */

    @Test
public void test7() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    // 先获取无参构造方法
    Constructor<?> constructor = aClass.getConstructor();
    Object obj = constructor.newInstance();
    Field nameField = aClass.getDeclaredField("name");
    Field ageField = aClass.getDeclaredField("age");
    Field addressField = aClass.getDeclaredField("address");
    // 私有的成员变量，使用前也要暴力反射
    nameField.setAccessible(true);
    ageField.setAccessible(true);
    nameField.set(obj,"rabbit");
    ageField.set(obj,22);
    addressField.set(obj,"上海");
    System.out.println(obj);
}

    image-20220302170955668

5、反射获取成员方法并使用

  • 测试一：获取所有公共方法，包括超类

    Method[] getMethods();
返回一个包含方法对象的数组，方法对象反映由该Class对象表示的类或接口的所有 公共方法
包括由类或接口声明的对象以及从超类和超级接口继承的类

    @Test
public void test8() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Method[] methods = aClass.getMethods();
    for (Method method : methods) {
        System.out.println(method);
    }
}

    image-20220302171858664

  • 测试二：获取所有方法，不包括超类

    /**
 * Method[] getDeclaredMethods();
 * 返回一个包含方法对象的数组，方法对象反映由该Class对象表示的类或接口的所有声明方法
 * 包括：public\protected\default(package)访问和私有方法，但不包括继承方法
 */

    @Test
public void test9() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Method[] methods = aClass.getDeclaredMethods();
    for (Method method : methods) {
        System.out.println(method);
    }
}

    image-20220302172055605

  • 测试三：返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法

    /**
 * Method getMethod(String name,Class<?>... parameterTypes );
 * 返回一个 方法对象，该对象反映由该 Class对象表示的类或接口的指定公共成员方法
 */

    @Test
public void test10() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");
    Method method = aClass.getMethod("method1");
    // 获取无参构造方法创建对象调用方法
    Constructor<?> constructor = aClass.getConstructor();
    Object obj = constructor.newInstance();
    // Object invoke(Object obj, Object... args)
    // 在具有指定参数的指定对象上调用此方法的对象表示的基础方法
    // obj:调用方法的对象
    // args:方法需要的参数
    method.invoke(obj);

}

    image-20220302173521343

image-20220302173606669

  • 练习4：通过反射实现如下操作

    /**
 * 练习：通过反射实现如下操作
 * Student student = new Student();
 * student.method1();
 * student.method2("rabbit");
 * String str = student.method("rabbit",22);
 * System.out.println(str);
 * str.function();
 */

    @Test
public void test12() throws Exception {
    // 获取Class对象
    Class<?> aClass = Class.forName("test.Student");

    // 获取无参构造方法创建对象调用方法
    Constructor<?> constructor = aClass.getConstructor();
    Object obj = constructor.newInstance();
    // student.method1()
    Method method1 = aClass.getMethod("method1");
    method1.invoke(obj);

    Method method2 = aClass.getMethod("method2", String.class);
    method2.invoke(obj,"rabbit");

    Method method3 = aClass.getMethod("method3", String.class, int.class);
    Object o = method3.invoke(obj, "rabbit", 22);
    System.out.println(o);

    Method function = aClass.getDeclaredMethod("function");
    function.setAccessible(true);
    function.invoke(obj);

}

    image-20220302175615693

  • 练习：通过反射越过泛型检查

    /**
 * 练习：越过泛型检查
 *  往 ArrayList<Integer> 中添加字符串对象
 */

    @Test
public void test13() throws Exception {
    ArrayList<Integer> list = new ArrayList<>();
    Class<? extends ArrayList> aClass = list.getClass();
    Method method = aClass.getMethod("add", Object.class);
    method.invoke(list,"hello world");
    System.out.println(list);
}

    image-20220302180228980

rabbit_zli
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java反射详解：核心概念、使用方法与实际应用
微笑听雨
06-03 1088
反射是一种机制，通过它，Java程序能够在运行时获取类的完整信息并进行操作，而不需要在编译时知道这些信息。反射的核心类都位于java.lang.reflect包中。
Java反射详解
最新发布
weixin_74268571的博客
06-22 2万+
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.反射就是把java类中的各种成分映射成一个个的Java对象。
Java中的反射
m0_67683346的博客
09-03 4908
Java的反射机制
Java基础之—反射
如果我爱自己我就会日出而坐，日落而息
09-02 318
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件...
java getconstructors_关于Java反射机制中通过getConstructors()方法获取类中全部构造方法顺序的问题...
weixin_39861905的博客
02-13 467
关于Java反射机制中通过getConstructors方法获取类中全部构造方法顺序的问题近日学习java反射机制的过程中了解到的getConstructors()方法，此方法用于取得全部构造方法，在测试过程发现了一些问题，希望与大家分享。问题引入以下代码用于取得Person类中的全部构造方法：package reflectDemo01;import java.lang.reflect.Const...
Java 反射使用大全
朱豪凯的博客
06-10 7847
好多年前自己记的关于Java反射的笔记，这么些年下来，自己用到反射的时候就看这一份就够了。但是笔记以文件形式存放不方便，所以将其放到CSDN中，也希望能给更多小伙伴带来帮助。
Java-反射机制（超详解）
weixin_52533007的博客
05-11 4万+
Java反射机制概述一、Java反射机制概述1. Java Reflection2. 动态语言 vs 静态语言二、 理解Class类并获取Class的实例1. 概述2. 方法3. 哪些类型可以有Class对象？4. 获取Class类的实例(四种方法)三、类的加载与ClassLoader的理解1. 类的加载过程2. 什么时候会发生类初始化？3. 类加载器的作用4. JVM中不同类型的类的加载器5.6. Properties：用来读取配置文件。四、 创建运行时类的对象五、获取运行时类的完整结构1. 获取当前
10分钟带你理解Java中的反射
09-01
在Java反射API中，主要涉及以下关键类和方法： 1. Class类： - `getFields()`：获取类的所有公共字段。 - `getDeclaredFields()`：获取类声明的所有字段，包括私有字段。 - `getMethods()`：获取类的所有公共...
一篇文章带你学懂Java反射
01-27
对于Java反射，平常工作中虽然经常用到，但一直以来都没有系统总结过，所以趁着目前有空总结一下，加深一下理解。如果发现谬误，欢迎各位批评指正。本文相关知识点大部分总结自Oracle官方文档。对于英文比较好的朋友...
Java反射以及在Android中的特殊应用
01-27
关于反射，一般书上的定义是这样的:JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的...
Java的反射中一些重要的方法
10-16
原理　JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射...
Java反射的三种实现方式
陌花拟的博客
05-27 1万+
Java反射的三种实现方式 Foo foo = new Foo(); 第一种：通过Object类的getClass方法 Class cla = foo.getClass(); 第二种：通过对象实例方法获取对象 Class cla = foo.class; 第三种：通过Class.forName方式 Class cla = Class.forName("xx.xx.Foo"); ...
java 反射机制调用函数
星空中的一颗星
09-11 2204
java反射机制 Refelction 反射映象倒影  即是 动态获取类有哪些属性和方法 在java里面 我们可以用反射机制在程序运行时 加载 探知 使用 编译期间完全未知的class 不包括方法定义package month9; import java.lang.reflect.Method; public class InvokeTester { public int add(int
JAVA中的反射机制
热门推荐
学会改变自己——才能突破
01-08 44万+
反射，当时经常听他们说，自己也看过一些资料，也可能在设计模式中使用过，但是感觉对它没有一个较深入的了解，这次重新学习了一下，感觉还行吧！            一，先看一下反射的概念：                主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。               反
java反射机制，函数调用
sinat_23619409的博客
05-11 1375
1.java反射机制：什么是反射 ：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。反射有什么用：1，在运行时判断任意一个对象所属的类；2，在运行时构造任意一个类的对象；3，在运行时判断任意一个类所具有的成员变量和方法；4，在运行时调用任意一个对象的方法；5...
关于Java反射机制中通过getConstructors()方法获取类中全部构造方法顺序的问题
MaYuKang的博客
01-28 5862
关于Java反射机制中通过getConstructors方法获取类中全部构造方法顺序的问题问题引入 近日学习java反射机制的过程中了解到的getConstructors()方法，此方法用于取得全部构造方法，在上机测试过程发现了一些问题，希望与大家分享。 问题引入 以下代码用于取得Person类中的全部构造方法： package reflectDemo01; import java.lang.re...
Java之反射——类对象
hk10066的博客
08-15 8455
学了一段时间Java了，但是还是很菜，看到反射这一节的时候，就有点厌烦，看不下去了，过了一段时间后我又翻了回来，因为要学习后面的，所以反射和注解这一块一定得搞明白，找了很多资料，以下是自己的总结，结合了很多大佬的东西。 1.什么是反射？     JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及...
学Java反射，看这篇就够了 | 原力计划
程序人生的博客
05-31 1174
作者 | P6级程序员责编 | 王晓曼出品 | CSDN博客首先学习反射之前，我要提出疑问：反射是个什么东西？它是用来做什么的？平时的应用场景有哪些？为啥要用它？它有什么优缺点？它的工作...
JAVA反射调用详解
Aka丶的博客
05-04 8034
JAVA反射调用的确是一种很神奇的机制，在项目中使用后恋恋不忘，现将其好好整理一下。 参考： 学习JAVA应该如何理解反射？知乎 https://www.zhihu.com/question/24304289 全面细致讲解反射机制系列 http://www.365yg.com/item/6414118008049893889/?iid=9697930986&app=news_artic
JAVA中的反射机制(内含大量实例)
04-26
JAVA中的反射机制是一种独特的能力，允许程序访问、检测和修改自身的状态或行为。这个概念最初由Smith在1982年提出，引起了计算机科学领域对应用反射性的广泛研究。反射机制的概念首先被程序语言的设计领域采用，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

rabbit_zli

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值