Java — 反射

已于 2022-04-30 23:22:01 修改
阅读量94 收藏
点赞数
分类专栏： # Java 文章标签： java
于 2021-08-01 18:16:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bybeiya/article/details/119301471
版权

文章目录

一、反射简介

程序在运行中也可以获取类的变量和方法信息，并通过获取到的信息来创建对象。程序不必再编译期就完成确定，在运行期仍然可以扩展。

示例：学生类

public class Student {
    // 成员变量：公共、受保护、默认、私有各一个
    public String name;
    protected String pwd;
    String sex;
    private int age;

    // 构造方法：公共两个，受保护、默认、私有各一个
    public Student() {
    }

    protected Student(String name) {
        this.name = name;
    }

    Student(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    private Student(String name, String pwd, String sex) {
        this.name = name;
        this.pwd = pwd;
        this.sex = sex;
    }

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

    // 成员方法：公共、受保护、默认、私有各一个
    public void method1() {
        System.out.println("public成员方法：method1");
    }

    protected void method2() {
        System.out.println("protected成员方法：method2");
    }

    void method3() {
        System.out.println("default成员方法：method3");
    }

    private void method4() {
        System.out.println("private成员方法：method4");
    }

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

二、Class 类

类名：Class<T>

包名：java.lang.Class<T>

Class 类和 Class 文件的关系：java.lang.Class 类用于表示一个类的字节码（.class）文件

通过反射获取对象的方式有以下三种：

方式描述
类名.class当该类被加载成 .class 文件时，此时该类变成了 .class，再获取该字节码文件对象，也就是获取自己， 该类处于字节码阶段
对象.getClass()通过类的实例获取该类的字节码文件对象，该类处于创建对象阶段
Class.forName(“全限定类名”)通过 Class 类中的静态方法 forName 直接获取到该类的字节码文件对象，此时该类还是源文件阶段，并没有变为字节码文件

测试：

public class Test_01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 类名.class
        Class<Student> s1 = Student.class;

        // 对象.getClass()
        Student student = new Student();
        Class<? extends Student> s2 = student.getClass();

        // Class.forName("包名.类名")
        Class<?> s3 = Class.forName("A_11_reflect.Student");

        System.out.println(s1 + "\n" + s2 + "\n" + s3);
        System.out.println(s1 == s2 && s1 == s3 && s2 == s3);
    }
}

运行：

class A_11_reflect.Student
class A_11_reflect.Student
class A_11_reflect.Student
true

三、构造方法

3.1、获取构造方法

修饰符和类型方法秒速
Constructor<?>[]getConstructors()返回该类所有的公共构造方法
ConstructorgetConstructor(Class<?>… parameterTypes)返回该类指定的公共构造方法
Constructor<?>[]getDeclaredConstructors()返回该类所有的构造方法
ConstructorgetDeclaredConstructor(Class<?>… parameterTypes)返回该类指定的构造方法

测试：

public class Test_02 {
    public static void main(String[] args) throws NoSuchMethodException {
        Class<Student> s = Student.class;

        // 获取该类所有的公共构造方法
        Constructor<?>[] constructors = s.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("constructor = " + constructor);
        }
        System.out.println("--------");

        // 获取该类指定的公共构造方法
        Constructor<Student> c1 = s.getConstructor();
        Constructor<Student> c2 = s.getConstructor(String.class, String.class, String.class, int.class);
        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
        System.out.println("--------");

        // 获取该类所有的构造方法
        Constructor<?>[] declaredConstructors = s.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("declaredConstructor = " + declaredConstructor);
        }
        System.out.println("--------");

        // 获取该类指定的构造方法
        Constructor<Student> c3 = s.getDeclaredConstructor();
        Constructor<Student> c4 = s.getDeclaredConstructor(String.class);
        Constructor<Student> c5 = s.getDeclaredConstructor(String.class, String.class);
        Constructor<Student> c6 = s.getDeclaredConstructor(String.class, String.class, String.class);
        Constructor<Student> c7 = s.getDeclaredConstructor(String.class, String.class, String.class, int.class);
        System.out.println("c3 = " + c3 + "\nc4 = " + c4 + "\nc5 = " + c5 + "\nc6 = " + c6 + "\nc7 = " + c7);
    }
}

运行：

constructor = public A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String,int)
constructor = public A_11_reflect.Student()
--------
c1 = public A_11_reflect.Student()
c2 = public A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String,int)
--------
declaredConstructor = public A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String,int)
declaredConstructor = private A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String)
declaredConstructor = A_11_reflect.Student(java.lang.String,java.lang.String)
declaredConstructor = protected A_11_reflect.Student(java.lang.String)
declaredConstructor = public A_11_reflect.Student()
--------
c3 = public A_11_reflect.Student()
c4 = protected A_11_reflect.Student(java.lang.String)
c5 = A_11_reflect.Student(java.lang.String,java.lang.String)
c6 = private A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String)
c7 = public A_11_reflect.Student(java.lang.String,java.lang.String,java.lang.String,int)

3.2、调用构造方法

类名：Constructor<T>

包名：java.lang.reflect.Constructor<T>

修饰符和类型构造方法描述
TnewInstance(Object… initargs)根据指定的构造方法创建对象
voidsetAccessible(boolean flag)值设为 true，取消访问检查（访问私有属性时会被检查）

测试：

public class Test_03 {
    public static void main(String[] args) throws Exception {
        Class<Student> s = Student.class;

        // 调用公共的无参构造方法创建对象
        Constructor<Student> c0 = s.getConstructor();
        Student student0 = c0.newInstance();
        System.out.println("student0 = " + student0);

        // 调用公共的有参构造方法创建对象
        Constructor<Student> c1 = s.getConstructor(String.class, String.class, String.class, int.class);
        Student student1 = c1.newInstance("张三", "123", "男", 23);
        System.out.println("student1 = " + student1);

        // 调用受保护的有参构造方法创建对象
        Constructor<Student> c2 = s.getDeclaredConstructor(String.class);
        Student student2 = c2.newInstance("李四");
        System.out.println("student2 = " + student2);

        // 调用默认的有参构造方法创建对象
        Constructor<Student> c3 = s.getDeclaredConstructor(String.class, String.class);
        Student student3 = c3.newInstance("王五", "123");
        System.out.println("student3 = " + student3);

        // 调用私有的有参造方法创建对象
        Constructor<Student> c4 = s.getDeclaredConstructor(String.class, String.class, String.class);
        c4.setAccessible(true); // 取消访问检查
        Student student4 = c4.newInstance("赵六", "123", "男");
        System.out.println("student4 = " + student4);
    }
}

运行：

student0 = Student{name='null', pwd='null', sex=null, age=0}
student1 = Student{name='张三', pwd='123', sex=男, age=23}
student2 = Student{name='李四', pwd='null', sex=null, age=0}
student3 = Student{name='王五', pwd='123', sex=null, age=0}
student4 = Student{name='赵六', pwd='123', sex=男, age=0}

四、成员变量

4.1、获取成员变量

修饰符和类型成员方法描述
Field[]getFields()返回该类所有的公共成员变量
FieldgetField(String name)返回该类指定的公共成员变量
Field[]getDeclaredFields()返回该类所有的成员变量
FieldgetDeclaredField(String name)返回该类指定的成员变量

测试：

public class Test_04 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<Student> s = Student.class;

        // 获取该类所有的公共成员变量
        Field[] fields = s.getFields();
        for (Field field : fields) {
            System.out.println("field = " + field);
        }
        System.out.println("--------");

        // 获取该类指定的公共成员变量
        Field name1 = s.getField("name");
        System.out.println("name1 = " + name1);
        System.out.println("--------");

        // 获取该类所有的成员变量
        Field[] declaredFields = s.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("declaredField = " + declaredField);
        }
        System.out.println("--------");

        // 获取该类指定的成员变量
        Field name = s.getDeclaredField("name");
        Field pwd = s.getDeclaredField("pwd");
        Field sex = s.getDeclaredField("sex");
        Field age = s.getDeclaredField("age");
        System.out.println("name = " + name + "\npwd = " + pwd + "\nsex = " + sex + "\nage = " + age);
    }
}

运行：

field = public java.lang.String A_11_reflect.Student.name
--------
name1 = public java.lang.String A_11_reflect.Student.name
--------
declaredField = public java.lang.String A_11_reflect.Student.name
declaredField = protected java.lang.String A_11_reflect.Student.pwd
declaredField = java.lang.String A_11_reflect.Student.sex
declaredField = private int A_11_reflect.Student.age
--------
name = public java.lang.String A_11_reflect.Student.name
pwd = protected java.lang.String A_11_reflect.Student.pwd
sex = java.lang.String A_11_reflect.Student.sex
age = private int A_11_reflect.Student.age

4.2、调用成员变量

类名：Field

包名：java.lang.reflect.Field

修饰符和类型成员方法描述
Objectset(Object obj, Object value)将 value 赋值给 obj 对象的成员变量
Objectget(Object obj)返回 obj 对象的成员变量值

测试：

public class Test_05 {
    public static void main(String[] args) throws Exception {
        Class<Student> s = Student.class;
        // 先获取所有成员变量
        Field name = s.getDeclaredField("name");
        Field pwd = s.getDeclaredField("pwd");
        Field sex = s.getDeclaredField("sex");
        Field age = s.getDeclaredField("age");
        // 调用无参构造方法
        Constructor<Student> c = s.getConstructor();
        // 实例化
        Student student = c.newInstance();
        // 成员变量赋值
        name.set(student, "张三");
        pwd.set(student, "123");
        sex.set(student, "男");
        age.setAccessible(true); // 私有成员需取消访问检查
        age.set(student, 23);
        System.out.println("student = " + student);
        System.out.println("--------");
        // 获取成员变量值
        System.out.println(name.get(student));
        System.out.println(pwd.get(student));
        System.out.println(sex.get(student));
        System.out.println(age.get(student));
    }
}

运行：

student = Student{name='张三', pwd='123', sex=男, age=23}
--------
张三
123
男
23

五、成员方法

5.1、获取成员方法

修饰符和类型成员方法描述
Method[]getMethods()返回该类所有的公共成员方法（包括继承的）
MethodgetMethod(String name, Class<?>… parameterTypes)返回该类指定的公共成员方法
Method[]getDeclaredMethods()返回该类所有的成员方法（不包括继承的）
MethodgetDeclaredMethod(String name, Class<?>… parameterTypes)返回该类指定的成员方法

测试：

public class Test_06 {
    public static void main(String[] args) throws Exception {
        Class<Student> s = Student.class;

        // 获取该类所有的公共成员方法（包括继承的）
        Method[] methods = s.getMethods();
        for (Method method : methods) {
            System.out.println("method = " + method);
        }
        System.out.println("--------");

        // 获取该类指定的公共成员方法
        Method method = s.getMethod("method1");
        System.out.println("method1 = " + method);
        System.out.println("--------");


        // 获取该类所有的成员方法（不包括继承的）
        Method[] declaredMethods = s.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("declaredMethod = " + declaredMethod);
        }
        System.out.println("--------");

        // 获取该类指定的成员方法
        Method method1 = s.getDeclaredMethod("method1");
        Method method2 = s.getDeclaredMethod("method2");
        Method method3 = s.getDeclaredMethod("method3");
        Method method4 = s.getDeclaredMethod("method4");
        System.out.println("method1 = " + method1 + "\nmethod2 = " + method2 + "\nmethod3 = " + method3 + "\nmethod4 = " + method4);
    }
}

运行：

method = public java.lang.String A_11_reflect.Student.toString()
method = public void A_11_reflect.Student.method1()
method = public final void java.lang.Object.wait() throws java.lang.InterruptedException
method = public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
method = public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
method = public boolean java.lang.Object.equals(java.lang.Object)
method = public native int java.lang.Object.hashCode()
method = public final native java.lang.Class java.lang.Object.getClass()
method = public final native void java.lang.Object.notify()
method = public final native void java.lang.Object.notifyAll()
--------
method1 = public void A_11_reflect.Student.method1()
--------
declaredMethod = public java.lang.String A_11_reflect.Student.toString()
declaredMethod = public void A_11_reflect.Student.method1()
declaredMethod = protected void A_11_reflect.Student.method2()
declaredMethod = void A_11_reflect.Student.method3()
declaredMethod = private void A_11_reflect.Student.method4()
--------
method1 = public void A_11_reflect.Student.method1()
method2 = protected void A_11_reflect.Student.method2()
method3 = void A_11_reflect.Student.method3()
method4 = private void A_11_reflect.Student.method4()

5.2、调用成员方法

类名：Method

包名：java.lang.reflect.Method

修饰符和类型成员方法描述
Objectinvoke(Object obj, Object… args)obj：调用方法的对象，args：方法的参数

测试：

public class Test_07 {
    public static void main(String[] args) throws Exception {
        Class<Student> s = Student.class;
        // 获取类的无参构造方法
        Constructor<Student> constructor = s.getConstructor();
        // 实例化
        Student student = constructor.newInstance();
        // 调用方法
        Method[] declaredMethods = s.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            declaredMethod.setAccessible(true); // 取消私有成员方法访问检查
            declaredMethod.invoke(student);
        }
    }
}

运行：

protected成员方法：method2
default成员方法：method3
private成员方法：method4
public成员方法：method1

六、反射示例

6.1、示例1

需求：往 ArrayList<Integer> 集合中添加字符串数据。

示例：

// 越过泛型检查
public class Test_08 {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        System.out.println("arrayList = " + arrayList);
        Class<? extends ArrayList> arrayListClass = arrayList.getClass();
        Method add = arrayListClass.getMethod("add", Object.class);
        add.invoke(arrayList, "张三");
        add.invoke(arrayList, "李四");
        add.invoke(arrayList, "王五");
        System.out.println("arrayList = " + arrayList);
    }
}

运行：

arrayList = [1, 2, 3]
arrayList = [1, 2, 3, 张三, 李四, 王五]

6.2、示例2

需求：通过 properties.txt 配置文件运行类中的方法。

示例：

className=A_11_reflect/demo/Student
methodName=study
parameter=张三

public class Student {
    public void study(String name) {
        System.out.println(name + "同学爱学习！");
    }
}

public class Teacher {
    public void study(String name) {
        System.out.println(name + "老师爱学习！");
    }
}

测试：

public class Test_01 {
    public static void main(String[] args) throws Exception {
        // 加载数据
        Properties p = new Properties();
        // 读取配置
        FileReader fr = new FileReader(".\\properties.txt");
        p.load(fr);
        fr.close();

        // 获取类名
        String className = p.getProperty("className");
        // 获取方法名
        String methodName = p.getProperty("methodName");
        // 获取参数
        String parameter = p.getProperty("parameter");

        // 反射获取类的实例
        Class<?> clazz = Class.forName(className);
        // 获取类的构造方法
        Constructor<?> con = clazz.getConstructor();
        // 类实例化
        Object o = con.newInstance();
        // 获取方法对象，指定参数类型
        Method m = clazz.getMethod(methodName, String.class);
        // o对象调用m方法传入parameter参数
        m.invoke(o, parameter);
        System.out.println("o = " + o);
    }
}

运行：

张三同学爱学习！
北涯
关注
专栏目录
java 反射
12-22
这种动态获取信息以及动态调用对象方法的功能成为java反射机制。 2. java 文件和 .class 文件的关系 java 文件 java文件中包含代码的所有内容，类，接口，成员变量，成员方法.... .class 字节码文件 .class 是由 ...
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射技术详解
热门推荐
黄林晴
04-14 24万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java反射（通俗易懂）
qq_51515673的博客
05-17 10万+
目录 1、反射介绍 2、反射API 2.1 获取类对应的字节码的对象（三种） 2.2 常用方法 3、反射的应用 3.1 创建 : 测试物料类 3.2 获取类对象 3.3 获取成员变量 3.4 通过字节码对象获取类的成员方法 3.5 通过字节码对象获取类的构造方法 4、创建对象 1、反射介绍 Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，...
Java反射的用途
果酱 の 博客
07-20 5135
Java反射是一项强大的特性，它为我们提供了在运行时获取和操作类的信息的能力。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至实现动态代理。Java反射是一种强大的特性，它允许我们在运行时获取和操作类的信息。通过反射，我们可以动态地创建对象、调用方法、访问和修改字段，甚至可以实现动态代理。通过动态代理，我们可以在运行时生成代理对象，并在代理对象中添加额外的逻辑。在许多情况下，我们需要在运行时获取类的信息，例如类的名称、修饰符、父类、接口等。通过反射，我们可以访问和修改对象的字段。
Java反射（超详细！）
一只小菜鸡
10-02 13万+
1、反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 2、反射机制的相关类在哪个包下？ java.lang.reflect.*; 3、反射机制相关的重要的类有哪些？ 类 含义 java.lang.Class 代表整个字节码。代表一个类型，代表整个类。 java.lang.reflect.Method 代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Con
Java 反射
卓原的进化之旅
11-15 1873
JAVA反射机制 JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制 功能 1、获得某个对象的属...
Java反射
qq_45847507的博客
04-20 2547
Java反射
JAVA反射
Dgs的博客
06-30 1341
JDK 反射使用
java反射调用get/set方法
吴名氏的博客
06-14 9万+
java反射调用get/set方法
Java反射介绍
派大星的博客
09-21 1539
总结介绍java反射基本知识，希望对java安全初学者有所帮助。
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
Java反射技术原理与用法实例分析
08-19
Java反射技术原理与用法实例分析 Java反射技术是Java语言中的一种动态语言技术，能够在运行时解析外部对象的信息。通过反射技术，可以动态地获取类以及类中的成员，并可以调用该类成员。 产生反射技术的需求： 在...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 461
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 956
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 994
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 1019
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
Java反射机制深入解析
Java反射机制是Java编程语言的一个核心特性，它使得程序在运行时可以获取自身的信息并能够动态地修改其行为。反射的概念源于1982年，最初应用于Lisp和面向对象语言中，并逐渐被广泛采用，包括在Java中。反射在计算机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值