Java反射机制

已于 2022-04-05 00:11:02 修改
阅读量718 收藏 4
点赞数 3
分类专栏： Javase_Javaee 文章标签： java 开发语言 后端
于 2022-01-18 18:15:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45464560/article/details/122559066
版权

Java反射机制

反射的概念

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它任意一个方法和属性。这种动态获取类信息以及动态调用对象方法的功能称为Java语言的反射机制。

Class类

Class类的介绍

  • Class类是Java中十分重要的一个类，我们想要使用反射，是离不开这个类的。
  • 当JVM加载一个class文件后，就会在内存中生成一个与之对应的Class对象，这个对象保存着该class文件的全部信息。
  • 同一类型的多个实例对象，它们的Class对象都是同一个，即在内存中每个Class对象都是独一无二的。

Class对象的获取

获取Class对象的方式有三种。

方式一：Class类的静态方法获取

使用该方式，意味着你的Java代码只有字节码文件，并没有进内存，我们需要手动的将字节码文件加载到内存，然后生成对应的Class对象、并获取Class对象

Class.forName("全类名") :将字节码文件加载进内存，返回Class对象

*多用于配置文件，将类名定义在配置文件中。读取文件加载类

方式二：类名获取

如果说内存中已经存在这个Class对象，那么我们就不需要再重新把字节码文件加载内存获取Class对象了。我们可以直接通过类名获取对应的Class对象

类名.class:通过类名的属性获取

*多用于参数的传递，例如方法中需要传递类

方式三：对象获取

若存在类实例对象，那么我们也可以通过该对象来获取该实例对象的Class对象。

对象.getClass(): getClass()方法在Object类中定义着。

*多用于对象获取字节码的方式

代码测试：
Person类：

package domain;

public class Person {
    public String name;
    public String sex;
    private int age;
    private String address;
    // 不同访问权限的成员变量 a b c d
    public String a;
    protected String b;
    String c; // default
    private String d;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

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

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

    public String getD() {
        return d;
    }

    public void setD(String d) {
        this.d = d;
    }

    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 Person() {
    }

    // 公有构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 私有构造方法
    private Person(String name) {
        this.name = name;
    }

    // 公共成员方法
    public void eat() {
        System.out.println("吃饭吃饭-------");
    }
    // 公共成员方法
    public void eat(String name) {
        System.out.println("吃"+name);
    }

    // 私有成员方法
    private void sleep() {
        System.out.println("睡觉睡觉-------");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}

测试类：

import domain.Person;

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {

        // 1、 Class类的静态方法获取 通过全类名
        Class<?> clazz1 = Class.forName("domain.Person");
        System.out.println(clazz1);

        // 2、 类名获取
        Class<Person> clazz2 = Person.class;
        System.out.println(clazz2);

        // 3、 对象获取
        Person p = new Person();
        Class clazz3 = p.getClass();
        System.out.println(clazz3);
        System.out.println("---------------------");
        // 看看这三个对象是否是同一个
        System.out.println(clazz1 == clazz2);   // true
        System.out.println(clazz2 == clazz3);   // true
    }
}

输出演示：
在这里插入图片描述
结论：
同一字节码文件（*.class）在一次程序运行过程中，只会被加载一次。不论通过哪一种方式获取的Class对象都是同一个。

通过Class对象获取 并 使用成员变量

获取成员变量

  • Field[] getFields()：获取所有public成员变量
  • Field getField(String name)：根据名称获取某个public成员变量
  • Field[] getDeclaredFields()：获取所有成员变量（任意权限修饰的，包括private）
  • Field getDeclaredField(String name)：根据名称获取某个成员变量（任意权限修饰的，包括private）

代码测试：

import domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class clazz1 = Person.class;

        System.out.println("------------ public成员变量们 ---------------");
        Field[] fields = clazz1.getFields();
        for (Field field: fields) {
            System.out.println(field);
        }

        System.out.println("------------ 通过名称获取某个public成员变量 ---------------");
        Field name = clazz1.getField("name");
        System.out.println(name);

        System.out.println("------------ 所有成员变量们 ---------------");
        Field[] declaredFields = clazz1.getDeclaredFields();
        for (Field field: declaredFields) {
            System.out.println(field);
        }

        System.out.println("------------ 通过名称获取某个成员变量 ---------------");
        Field d = clazz1.getDeclaredField("d");
        System.out.println(d);
    }
}

输出显示：
在这里插入图片描述

使用成员变量

上面我们获取了某个类的成员变量Field，那么我们能拿成员变量干什么呢？
其实无非就是两个操作：设置值 和 获取值

  • Field getField(String name)：获取值
  • void set(Object obj, Object value)：设置值

演示代码：

import domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Person p1 = new Person("coderzpw",22);
        Class clazz1 = p1.getClass();
        Field name = clazz1.getField("name");
        // 通过反射 获取 p1对象的name
        Object name1 = name.get(p1);
        System.out.println(name1);
        // 通过反射 设置 p1对象的name
        name.set(p1, "小虎牙");
        System.out.println(p1.name);
    }
}

输出显示：
在这里插入图片描述
其实上面我们使用的成员变量name它是一个public的。我相信大家肯定会有疑问，私有的成员变量我们可以获取并设置吗？
接下来我们来试一下：

import domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Person p1 = new Person();
        p1.setD("小D");
        Class clazz1 = p1.getClass();
        Field d = clazz1.getDeclaredField("d");
        // 通过反射 获取 p1对象的d
        Object d1 = d.get(p1);
//        System.out.println(d1);
//        // 通过反射 设置 p1对象的d
//        d.set(p1, "大D");
//        System.out.println(p1.getD());
    }
}

结果：
在这里插入图片描述
直接报错了，告诉我们是非法操作！！！
难道我们真的无法通过反射使用p1的d属性吗？ 当然可以使用，在反射面前一切访问权限都形同虚设。
看我操作：

import domain.Person;

import java.lang.reflect.Field;

public class ReflectDemo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        Person p1 = new Person();
        p1.setD("小D");
        Class clazz1 = p1.getClass();
        // 获取private成员变量 d
        Field d = clazz1.getDeclaredField("d");
        // 忽略访问权限修饰符的安全检查
        d.setAccessible(true);  // 暴力反射
        // 通过反射 获取 p1对象的d
        Object d1 = d.get(p1);
        System.out.println(d1);
        // 通过反射 设置 p1对象的d
        d.set(p1, "大D");
        System.out.println(p1.getD());
    }
}

输出演示：
在这里插入图片描述
获取、设置成功！！！其实跟上面代码不同点，就是加了d.setAccessible(true); ，这一点是关键

// 忽略访问权限修饰符的安全检查
d.setAccessible(true);  // 暴力反射

通过Class对象获取 并 使用构造方法

获取构造方法对象

  • Constructor<T> getConstructor(Class<?>... parameterTypes)：根据你的参数类型，获取public修饰的构造方法
  • Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：根据你的参数类型，获取任意权限修饰的构造方法，包括private
  • T newInstance()：直接通过Class对象调用无参构造方法，创建实例

使用构造方法对象创建实例

T newInstance(Object ... initargs)： 传入对应的参数即可

代码案例：

import domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        Class clazz1 = Person.class;
        // 通过public的构造方法 初始化一个对象
        Constructor constructor1 = clazz1.getConstructor(String.class, int.class);
        Object person1 = constructor1.newInstance("coderzpw", 22);
        System.out.println(person1);

        // 通过private的构造方法 初始化一个对象（需要加暴力反射代码,不加的话也会报错）
        Constructor constructor2 = clazz1.getDeclaredConstructor(String.class);
        // 忽略访问权限修饰符的安全检查
        constructor2.setAccessible(true);  // 暴力反射
        Object person2 = constructor2.newInstance("小虎牙");
        System.out.println(person2);

        // 直接通过Class对象创建实例(必须是无参的)
        Object o = clazz1.newInstance();
        System.out.println(o);
    }
}

输出演示：
在这里插入图片描述

通过Class对象获取 并 使用成员方法

获取成员方法对象

  • Method[] getMethods()：获取所有public成员方法，包括父类的方法
  • Method[] getDeclaredMethods()：获取获取任意权限修饰的成员方法，但不包括父类的方法
  • Method getMethod(String name, Class<?>... parameterTypes)：根据方法名以及参数类型获取指定方法
  • Method getDeclaredMethod(String name, Class<?>... parameterTypes)：根据方法名以及参数类型获取指定方法（任意访问修饰符修饰的，包括private）

getMethods代码演示：

public class ReflectDemo5 {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        Method[] methods = clazz1.getMethods();
        for (Method method: methods) {
            System.out.println(method);
        }
    }
}

输出演示：
在这里插入图片描述getDeclaredMethods代码演示：

import domain.Person;

import java.lang.reflect.Method;

public class ReflectDemo5 {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        // 获取所有的方法（任意访问修饰符，包括private） 但是不包括父类的方法
        Method[] declaredMethods = clazz1.getDeclaredMethods();
        for (Method m: declaredMethods) {
            System.out.println(m);
        }
    }
}

输出演示：

在这里插入图片描述
getMethod 和 getDeclaredMethod 代码演示：

import domain.Person;

import java.lang.reflect.Method;

public class ReflectDemo5 {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        Method eatMethod1 = clazz1.getMethod("eat");
        Method eatMethod2 = clazz1.getMethod("eat", String.class);
        Method sleepMethod = clazz1.getDeclaredMethod("sleep");
        System.out.println(eatMethod1);
        System.out.println(eatMethod2);
        System.out.println(sleepMethod);
    }
}

输出演示：
在这里插入图片描述

通过方法对象调用某个对象的方法

Object invoke(Object obj, Object... args)：调用某个对象的方法，第一个参数是指定对象，其他参数都是方法的形参

invoke代码演示：

import java.lang.reflect.Method;

public class ReflectDemo5 {
    public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        Method eatMethod2 = clazz1.getMethod("eat", String.class);
        Method sleepMethod = clazz1.getDeclaredMethod("sleep");
        eatMethod2.invoke(p1, "火锅");
        // 忽略访问权限修饰符的安全检查
        sleepMethod.setAccessible(true);    // 暴力反射
        sleepMethod.invoke(p1);
    }
}

输出演示：

在这里插入图片描述

总结

  • 其实Class对象、Field对象、Constructor对象和Method对象都有对应的getName()方法，获取对应的名字，这里就不演示了
  • 无论是获取Field对象、Constructor对象和Method对象，如果是加s的都是获取复数，不加s的是获取指定的一个（一般都需要指定条件）
  • 一般带Declared的，都可以获取任意访问修饰符修饰的，包括private。但是如果使用private的对象的话，需要提前调用对应的setAccessible(true)方法
coderzpw
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
java 反射机制
08-31
本文将深入探讨Java反射机制，并结合给出的代码示例进行解析。 首先，我们来看如何通过反射获取类的基本信息。在代码中，`Class.forName("reflection.User")` 是用来加载名为 `User` 的类，返回一个 `Class` 对象。...
java.lang.Class<T> -- 反射机制及动态代理
limeOracle的博客
01-09 124
Interface ： Person package java_.lang_.component.bean; public interface Person { String area = "earth"; public void userAxe(); public void personLaught(); } ...
java反射（2）：类（Class<T>）
menergy
12-02 3349
第0章：简介 第1章：Class工具类 Class工具类ClassUtils.java如下：
java class类 反射_Java Class类及反射机制
weixin_28020031的博客
02-16 177
java.lang.Class类声明：public final class Classextends Object implements Serializable, GenericDeclaration, Type, AnnotatedElementT - 由此 Class 对象建模的类的类型。例如， String.class 的类型是 Class。如果将被建模的类未知，则使用 Class>...
java反射中的T_Java反射API研究(3)——java.lang.Class<T>
weixin_28921621的博客
02-28 231
对于反射来说，Class是核心，任何反射的对象都需要通过Class来获得。Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)...
java.lang.Class<T> -- 反射机制
limeOracle的博客
12-29 66
1反射机制是什么 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 2反射机制能做什么 反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任...
JAVA反射机制实例教程
09-04
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以访问和修改私有成员，调用私有方法，创建对象，以及对类、接口、字段和方法进行操作，极大地...
Java反射机制用法总结
08-25
Java反射机制是Java语言提供的一种强大的工具，它允许程序在运行时动态地获取类的信息并进行操作。在Java中，每个类都是一个`java.lang.Class`的实例，这使得我们能够在运行时检查类的结构，包括其属性、方法和构造...
反射（离不开java.lang.Class<T> 类 & 类加载器）
krismile__qh的博客
04-23 676
耐心看完下面的讲解你会受益匪浅~ 1.先简单介绍一下java.lang.Class<T>： T - 由此 Class 对象建模的类的类型。 Class 类的实例表示正在运行的 Java 应用程序中的类和接口。 2.由Java代码在计算机中经历的三个阶段来引入反射： （Java类编译为.class文件，从.class文件加载到虚拟机内存中开始，到卸载出内存为止，它的整个生...
java list<>类型动态_java,关于利用反射自动设置List<T>中T的类型
weixin_32486581的博客
02-16 685
用代码给你例子：import java.util.*;public class A{List list = null;static int b;int a = 0;private A(){ //这虽然是使用了private声明的构造函数//但是在使用newInstance()方法时调用的是这个构造函数//如果类中声明了其他构造函数且没有默认构造函数的话，会出错...
看懂Class＜T＞ clazz；所需的Java基础知识
weixin_45598285的博客
01-20 1万+
参考博文： https://blog.csdn.net/u012990509/article/details/61494047?spm=1001.2101.3001.6650.6&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-6.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.
BaseDAO开发及获取泛型的传输数据类型（Class<T>）实例讲解
前尘叆夢
05-17 4735
一般在涉及DAO开发时，常用到的增删改查方法会封装到一个基类（BaseDAO），对于各个数据表的基本维护业务都需要用到增删改查等方法。 若对每张表都编写一套增删改差方法未必有些麻烦，并且不符合编码的基本准则。一般，我们可以将这些功能的所公用的部分封装为一个对象，或者是类，此类是所有DAO的 基类，可以称为：BaseDAO。 由于此类接收到不同的操作对象，故需泛型的支持。 下面，我通过以下实
深入理解Java类型信息(Class对象)与反射机制
热门推荐
zejian的博客
05-01 16万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/70768369 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
Java反射机制详解
我的博客
05-08 143
1反射机制是什么 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 2反射机制能做什么 反射机制主要提供了以下功能：  在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断
7、利用泛型和反射,让public static <T> T findById(Class<T> clazz, int id)方法,更具一般性
Learning
03-15 5236
1、前面讲到的findById(int id),只是一个仅仅针对user表的操作,为了使得查找方法更具有一般性,引入了泛型和反射 2、利用泛型和反射,让public static T findById(Class clazz, int id)方法,更具一般性.MyJDBCUtils的代码如下 package com.jdbc.genericity.utils; import java.la
java反射-打印clazz
八度易飞
02-09 129
分别打印： clazz clazz.getName() clazz.getSimpleName()
【Java笔记（7）】反射实例化对象clazz.getDeclaredConstructor().newInstance()跟class.newInstance()
weixin_43493559的博客
06-07 3944
目录一、Class类的实例化方式二、反射实例化对象三、关键字总结 一、Class类的实例化方式 package reflect; import java.util.Date; /** * Class类对象的三种形式，三种形式都很重要 * * @ClassName: ClassObjectThreeDome * @Author: Xlu103 * @Date: 2020-06-07 19:14 **/ public class ClassObjectThreeDome { //注意会抛出
Java反射机制详解与应用
"学习目标-理解Java反射机制，掌握Reflection API的使用，了解抽象工厂模式在反射中的应用。" 在Java编程中，反射机制是一种强大的工具，它允许我们在程序运行时检查类、接口、字段和方法的信息，甚至能够在运行时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

coderzpw

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

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

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

打赏作者

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

抵扣说明：

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

余额充值