Java反射

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量394 收藏 8
点赞数 11
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwwee123/article/details/135744709
版权

Java反射

一、获取class对象

1.1 Studnet类

package reflection;

public class Student {
    private String name;
    private int age;
}

1.2 获取class对象有三种方式

  • Class.forName(“全类名”)
  • 类名.class
  • 对象.class
package reflection;

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

        // 1.Class.forName("全类名")
        // 经常使用，很多实现都是用这种，idea各种代码提示
        Class class1 = Class.forName("reflection.Student");

        // 2.类名.class
        // 一般当参数时使用 例如：synchronized (Student.class) {}
        Class class2 = Student.class;


        // 3.对象.class
        // 很少用
        Class class3 = new Student().getClass();

        // 三种获取方法都是同样的
        System.out.println(class1 == class2);   // true
        System.out.println(class3 == class2);   // true
    }
}

二、反射获取构造方法

2.1 Studnet类

package reflection;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    protected Student(int age) {
        this.age = age;
    }

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

2.2 通过反射获取构造方法的方式

  • 获取所有公有的构造方法Constructor<?>[] getConstructors()
  • 获取所有的构造方法Constructor<?>[] getDeclaredConstructors()
  • 按参数获取单个公有的构造方法Constructor<?> getConstructor()
  • 按参数获取单个任意权限构造方法Constructor<?> getDeclaredConstructor()
package reflection;

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

public class ConstructorTest {
    public static void main(String[] args) throws Exception {
        Class<Student> clazz = Student.class;
        
        // 1.获取**所有公有**的构造方法
        Constructor<?>[] cons1 = clazz.getConstructors();
        for (Constructor<?> constructor : cons1) {
            System.out.println(constructor);
        }
        /*
            输出：
            public reflection.Student(java.lang.String,int)
            public reflection.Student()
         */

        // 2.获取**所有**的构造方法
        Constructor<?>[] cons2 = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : cons2) {
            System.out.println(constructor);
        }
        /*
            输出：
            private reflection.Student(java.lang.String)
            protected reflection.Student(int)
            public reflection.Student(java.lang.String,int)
            public reflection.Student()
         */

        // 3.参数获取**单个任意权限**构造方法
        Constructor<Student> cons3 = clazz.getDeclaredConstructor();
        System.out.println(cons3);  // public reflection.Student()
        
        Constructor<Student> cons4 = clazz.getDeclaredConstructor(int.class);
        System.out.println(cons4);  // protected reflection.Student(int)

        Constructor<Student> cons5 = clazz.getDeclaredConstructor(String.class);
        System.out.println(cons5);  // private reflection.Student(java.lang.String)

        Constructor<Student> cons6 = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons6);  // public reflection.Student(java.lang.String,int)

        // 4.按参数获取**单个公有**的构造方法
        // clazz.getConstructor()
        // 和3基本相同 略...
    }
}

2.3 Constructor构造方法对象的应用

  • 暂时跳过权限校验 ``void setAccessible()`
  • 调用构造方法 T newInstance()
package reflection;

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

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

        // 通过构造方法对象cons获取方法参数
        Constructor<Student> cons = clazz.getDeclaredConstructor(String.class);
        System.out.println(Arrays.toString(cons.getParameters()));  // [java.lang.String arg0]

        // 这个方法是private修饰的，可以通过setAccessible(true)，强制跳过权限校验
        System.out.println(cons); // private reflection.Student(java.lang.String)
        // 暴力反射
        cons.setAccessible(true);
        cons.newInstance("name");
    }
}

2.4 获取构造方法的修饰符

  • 获取修饰符 int getModifiers()
package reflection;

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

public class ConstructorTest {
    public static void main(String[] args) throws Exception {
        Class<Student> clazz = Student.class;
        System.out.println(cons.getModifiers());	// 2		
    }
}

利用二进制位来表示是否有对应的修饰符:

image-20231112223602986

三、反射获取成员变量

3.1 Studnet类

package reflection;

public class Student {
    private String name;
    public int age;
    
    public Student() {
    }

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

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

获取的方式和构造方法基本一样，Constructor 和 Field 的区别

3.2 通过反射获取成员变量的方式

  • 获取所有公有的成员变量 Field[] getFields()
  • 获取所有的成员变量 Field[] getDeclaredFields()
  • 获取单个公有的成员变量 Field getField(变量名)
  • 获取单个任意权限的成员变量 Field getDeclaredField(变量名)
package reflection;

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

public interface FieldsTest {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("reflection.Student");

        // 1.获取**所有公有**的成员变量 `Field[] getFields()`
        Field[] field1 = clazz.getFields();
        System.out.println(Arrays.toString(field1));    // [public int reflection.Student.age]

        // 2.获取**所有**的成员变量 `Field[] getDeclaredFields()`
        Field[] fields2 = clazz.getDeclaredFields();
        System.out.println(Arrays.toString(fields2));
        // 输出：
        // [private java.lang.String reflection.Student.name, public int reflection.Student.age]

        // 3.获取单个公有的成员变量 `Field[] getField(变量名)`
        Field fields3 = clazz.getField("age");
        System.out.println(fields3);    // public int reflection.Student.age

        // 4.获取**单个任意权限**的成员变量 `Field[] getDeclaredField(变量名)`
        Field fields4 = clazz.getDeclaredField("name");
        System.out.println(fields4);    // private java.lang.String reflection.Student.name

        // 1.获取修饰符，和上述构造方法一样
        System.out.println(fields4.getModifiers()); // 2

        // 2.获取变量名
        System.out.println(fields4.getName());  // name

        // 3.通过反射对一个对象的变量进行操作
        Student stu = new Student("lisi", 28);

        fields4.setAccessible(true);    // 暂时跳过权限校验
        // 3.1尽管没有get方法，且还是private的也可以获取到
        System.out.println(fields4.get(stu));   // lisi

        // 3.2尽管没有set方法，且还是private的也可以设置
        fields4.set(stu, "zhangsan");
        System.out.println(stu);    // Student{name='zhangsan', age=28}

    }
}

3.3 Field成员变量对象的应用

  • 获取修饰符 int getModifiers()
  • 获取变量名String getName()
  • 暂时跳过权限校验 ``void setAccessible()`
  • 获取对象的值 Object get()
  • 设置对象的值 void set()
package reflection;

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

public interface FieldsTest {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("reflection.Student");
        
        // 获取私有成员变量name
        Field field = clazz.getDeclaredField("name");

        // 1.获取修饰符，和上述构造方法一样
        System.out.println(field.getModifiers()); // 2

        // 2.获取变量名
        System.out.println(field.getName());  // name

        // 3.通过反射对一个对象的变量进行操作
        Student stu = new Student("lisi", 28);

        field.setAccessible(true);    // 暂时跳过权限校验
        // 3.1尽管没有get方法，且还是private的也可以获取到
        System.out.println(field.get(stu));   // lisi

        // 3.2尽管没有set方法，且还是private的也可以设置
        field.set(stu, "zhangsan");
        System.out.println(stu);    // Student{name='zhangsan', age=28}
    }
}

三、反射获取成员方法

4.1 Studnet类

package reflection;

public class Student {
    private String name;
    public int age;
    
    public Student() {
    }

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

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

获取的方式和构造方法和成员变量一样，Constructor 、Field 和 Method 的区别

4.2 通过反射获取成员方法的方式

  • 获取所有公有的成员方法（包括父类的公有方法）Method[] getMethods()
  • 获取所有的成员方法（不包括父类的方法）Method[] getMethodFields()
  • 获取单个公有的成员方法 （包括父类的公有方法）Method getMethod()
  • 获取单个任意权限的成员方法（不包括父类的方法）Method getDeclaredMethod()
package reflection;

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

public class MethodTest {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("reflection.Student");

        // 1.获取**所有公有**的成员方法（**包括父类的公有方法**）`Method[] getMethods()`
        Method[] method1 = clazz.getMethods();
        System.out.println(Arrays.toString(method1));
        System.out.println("====================");

        // 2.获取**所有**的成员方法（**不包括父类的方法**）`Method[] getMethodFields()`
        Method[] method2 = clazz.getDeclaredMethods();
        System.out.println(Arrays.toString(method2));
        System.out.println("====================");

        // 3.获取**单个公有**的成员方法 （**包括父类的公有方法**）`Method[] getMethod()`
        Method method3 = clazz.getMethod("eat", String.class, int.class);
        System.out.println(method3);
        System.out.println("====================");

        // 4.获取**单个任意权限**的成员方法（**不包括父类的方法**）`Method[] getDeclaredMethod()`
        Method method4 = clazz.getDeclaredMethod("eat", String.class);
        System.out.println(method4);

    }
}

程序运行结果：

image-20231114204230030

·

4.3 Method成员方法对象的应用

  • 获取修饰符 int getModifiers()
  • 获取变量名String getName()
  • 暂时跳过权限校验 void setAccessible()
  • 获取方法参数 Parameter[] getParameters()
  • 获取方法抛出的异常 Class<?>[] getExceptionTypes()
  • 调用该方法 Object invoke()
package reflection;

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

public class MethodTest {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("reflection.Student");
        
        // 获取私有方法eat()
        Method method = clazz.getDeclaredMethod("eat", String.class);

        // 1.获取修饰符 `int getModifiers()`
        System.out.println(method.getModifiers()); // 2
        System.out.println("====================");

        // 2.获取变量名`String getName()`
        System.out.println(method.getName());  // eat
        System.out.println("====================");

        // 3.获取方法参数 `Parameter[] getParameters()`
        System.out.println(Arrays.toString(method.getParameters()));   // [java.lang.String arg0]
        System.out.println("====================");

        // 4.获取方法抛出的异常 `Class<?>[] getExceptionTypes()`
        System.out.println(Arrays.toString(method.getExceptionTypes()));
        // 输出：
        // [class java.io.IOException, class java.lang.RuntimeException]
        System.out.println("====================");

        // 5.调用该方法 `Object invoke()`
        method.setAccessible(true);    // 暂时跳过权限校验
        Object result = method.invoke(new Student(), "苹果");    // 在吃：苹果
        System.out.println(result); // ok
    }
}

四、利用反射保存任意对象信息

想想如果不用反射的话，还需要利用get()方法一个个调用，并且最根本的是无法判断该对象的属性到底有哪些。

利用反射中getDeclaredFields()操作即可对变量为所欲为！！！暴力！

package reflection;

import java.lang.reflect.Field;

public class SaveTest {
    public static void main(String[] args) throws IllegalAccessException {
        Student stu = new Student("Lisi", 18);
        Teacher tch = new Teacher("LaoWang", 9999);
        save(stu);
        System.out.println("===============");
        save(tch);
    }

    /**
     * 保存任意对象的信息
     * @param obj
     * @throws IllegalAccessException
     */
    public static void save(Object obj) throws IllegalAccessException {
        // 1.通过对象获取到类的字节码文件
        Class<?> clazz = obj.getClass();

        // 2.调用getDeclaredFields()方法获取所以成员变量
        for (Field field : clazz.getDeclaredFields()) {
            // 3.跳过权限，可能为private
            field.setAccessible(true);
            // 4.获取变量名
            String name = field.getName();
            // 4.获取变量对应的值
            Object value = field.get(obj);
            System.out.println(name + " : " + value);
            // 5.保存到文件... ，略
        }
    }
}

输出结果：

image-20231114213020942

五、总结

image-20231114214238510

LY_yyy.
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java反射技术详解
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
java 反射
喵酱
03-29 2306
参考资料： Java反射技术详解_黄林晴的博客-CSDN博客_java反射 Java高级篇（四）——反射 - JAdam - 博客园 一、什么是反射 　　反射就是把Java类中的各个成分映射成一个个的Java对象。 即在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能调用它的任意一个方法和属性。 这种动态获取信息及动态调用对象方法的功能叫Java的反射机制。 1. 反射机制的功能 　　Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属
java反射调用get/set方法
热门推荐
吴名氏的博客
06-14 9万+
java反射调用get/set方法
Java反射案例
01-09
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类集中在java.lang.reflect包下，包括Class、Constructor、Method和Field...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
深入理解Java反射
09-01
Java反射是Java编程语言的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。在深入探讨反射之前，我们先要明白类型信息的概念。类型信息是指在程序运行时，关于类、接口、对象的具体信息，包括...
Java反射实例
09-10
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类是`java.lang.Class`，它代表了类的信息。通过反射，我们可以动态地...
Java内存模型
最新发布
weixin_44267758的博客
07-19 338
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 874
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 648
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 930
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 175
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 514
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 597
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 534
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 524
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
Java反射机制详解与应用
"学习目标-理解Java反射机制，掌握Reflection API的使用，了解抽象工厂模式在反射中的应用。" 在Java编程中，反射机制是一种强大的工具，它允许我们在程序运行时检查类、接口、字段和方法的信息，甚至能够在运行时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值