Java反射机制

最新推荐文章于 2025-05-24 15:24:14 发布
最新推荐文章于 2025-05-24 15:24:14 发布
阅读量63 收藏
点赞数
文章标签： javascript 运维 ruby ViewUI
原文链接：https://my.oschina.net/u/2361475/blog/600601
版权

动态语言

程序运行的时，可以改变程序结构或变量类型。典型的语言：
    Python,ruby,javascript等
    如javascript代码：
        function test(){
            var s = "var a = 3, var b = 4; alert(a+b)";
            eval(s);
        }

C、C++、Java不是动态语言，但是Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
Java的动态性让编程的时候更加灵活。

反射机制

  • 指的是可以运行时加载、探知、使用编译期间完全未知的类。

  • 程序在运行状态中，可以加载一个只有名称的类，对于任意一个已加载的类，都能够知道它的方法 和属性，对于任意一个对象，都能调用它的任意一个方法和属性。

  • 加载完类之后，在堆内存（HotSpot虚拟机是在方法区），就会产生一个Class对象（一个类只用一个Class 对象），这个对象包含整个类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，通过这个镜子可以个看到 类的结构，所以我们称之为“反射”。

Class类介绍

jdk对Class的介绍：

Class类的实例表示正在运行的Java应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。 Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

总结：

  • Class类的对象包含了某个被加载类的结构，一个被加载类的对应一个Class对象。

  • 当一个类被加载，或当加载器的defineClass()被JVM掉用，JVM便自动产生一个Class对象。

  • Class类是反射的根源。

获取Class对象

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // (1)forName()获取Class对象(最常用)
        Class clazz1 = Class.forName("reflection.Student");
        System.out.println(clazz1.hashCode());
        // (2).class获取Class对象
        Class clazz2 = String.class;
        System.out.println(clazz2.hashCode());
        // (3)getClass()获取Class对象
        // 一个类只对应一个Class对象
        Class clazz3 = "reflection.Student".getClass();
        System.out.println(clazz3.hashCode());


        //每个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象
        int[] arr01 = new int[10];
        int[][] arr02 = new int[30][3];
        int[] arr03 = new int[30];
        double[] arr04 = new double[10];

        System.out.println(arr01.getClass().hashCode());
        System.out.println(arr02.getClass().hashCode());
        System.out.println(arr03.getClass().hashCode());
        System.out.println(arr04.getClass().hashCode());
    }
}

反射调用方法、属性、构造器

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

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

    private void myPrivateMethod(){

    }

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

    //默认构造器反射的时候不要省略
    public Student() {
    }
}

public class ClassTest {
    public static void main(String[] args) throws Exception {
        // 获得类型
        Class clazz = Class.forName("reflection.Student");
        System.out.println(clazz.getName());
        System.out.println(clazz.getSimpleName());
        // 获得属性
        // 获取全部方法
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println("全部的属性:" + field.getName());
        }
        // 获取public修饰的方法
        Field[] fields1 = clazz.getFields();
        for (Field field : fields1) {
            System.out.println("私有的属性:" + field.getName());
        }
        // 获得方法
        // 获得全部方法
        Method[] methods = clazz.getDeclaredMethods();
        // 方法名字 + 无参数
        Method m01 = clazz.getDeclaredMethod("getName", null);
        // 方法名 + 有参数
        Method m02 = clazz.getDeclaredMethod("setName", String.class);
        for(Method m:methods){
            System.out.println("方法："+m);
        }
        // 获得构造器
        Constructor[] constructors = clazz.getDeclaredConstructors();
        Constructor c = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println("获得构造器："+c);
        for(Constructor temp:constructors){
            System.out.println("构造器："+temp);
        }
    }
}

//反射生成对象、调用普通方法、修改属性
public class ClassTest3 {
    public static void main(String[] args) throws Exception {
        //默认构造器产生对象
        Class<Student> clazz = (Class<Student>) Class.forName("reflection.Student");
        System.out.println(clazz.newInstance());

        //指定构造器产生对象
        Constructor<Student> c = clazz.getDeclaredConstructor(String.class, int.class);
        Student student = c.newInstance("xiaoming", 12);
        System.out.println("指定构造器产生对象后获取姓名: " + student.getName());

        //反射调用普通方法
        Method m = clazz.getDeclaredMethod("setName", String.class);
        m.invoke(student, "XIAOHUA ");
        System.out.println("反射调用普通方法修改姓名后获取姓名: " + student.getName());

        //修改该属性
        Student student1 = clazz.newInstance();
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);
        field.set(student1, "wjk");
        System.out.println(student1.getName());
        System.out.println(field.get(student1));
    }
}

反射的效率

setAccessible（boolean flag）

(1) 将此对象的 accessible 标志设置为指示的布尔值。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false 则指示反射的对象应该实施 Java 语言访问检查。

(2) 设置false效率提高。

//验证
public class ClassTest4 {
    public static void test1() {
        Student student = new Student();
        long start = System.currentTimeMillis();
        for (Long i = 1L; i < 1000000L; i++) {
            student.getName();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void test2() throws Exception {
        Student student = new Student();
        Class clazz = student.getClass();
        Method method = clazz.getDeclaredMethod("getName", null);
        long start = System.currentTimeMillis();
        for (Long i = 1L; i < 1000000L; i++) {
            method.invoke(student);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

    }

    public static void test3() throws Exception {
        Student student = new Student();
        Class clazz = student.getClass();
        Method method = clazz.getDeclaredMethod("getName", null);
        method.setAccessible(true);
        long start = System.currentTimeMillis();
        for (Long i = 1L; i < 1000000L; i++) {
            method.invoke(student);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);

    }

    public static void main(String[] args) throws Exception {
        test1();
        test2();
        test3();
    }
}
//结果
37
72
48

反射操作泛型

public class ClassTest5 {
    public static void test1(List<String> strings, Map<String, Object> map) {
        System.out.println("test1");
    }

    public static List<String> test2() {
        return null;
    }

    public static void main(String[] args) throws Exception {
        Class clazz = ClassTest5.class;
        Method m = clazz.getMethod("test1", List.class, Map.class);
        Type[] t = m.getGenericParameterTypes();
        for (Type type : t) {
            System.out.println("#" + type);
            if (type instanceof ParameterizedType) {
                Type[] genericTypes = ((ParameterizedType) type).getActualTypeArguments();
                for (Type genericType : genericTypes) {
                    System.out.println("泛型类型：" + genericType);
                }
            }
        }


        Method m2 = ClassTest5.class.getMethod("test2", null);
        Type returnType = m2.getGenericReturnType();
        if (returnType instanceof ParameterizedType) {
            Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

            for (Type genericType : genericTypes) {
                System.out.println("返回值，泛型类型：" + genericType);
            }

        }

    }
}
//结果
#java.util.List<java.lang.String>
泛型类型：class java.lang.String
#java.util.Map<java.lang.String, java.lang.Object>
泛型类型：class java.lang.String
泛型类型：class java.lang.Object
返回值，泛型类型：class java.lang.String

反射操作注解

参考：http://my.oschina.net/u/2361475/blog/597726


转载于:https://my.oschina.net/u/2361475/blog/600601

chengyiwo8128
关注
Java 反射机制
水w的博客
10-08 1048
Java 反射机制
Java反射机制原理
Palpitate_fx的博客
06-19 1179
Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。第一种是从reflectionData直接取，reflectionData是弱引
Java反射机制详解
weixin_53840353的博客
08-16 2559
反射指的是程序在运行时可以访问、检测和修改它自己的状态或行为。Java反射机制提供了一些类和接口，允许开发者在运行时获取类的元数据（如类名、方法、属性等），并对这些元数据进行操作。Java反射机制是一个强大的工具，允许开发者在运行时动态操作类的结构和行为。尽管反射带来了一定的性能开销和代码复杂性，但在许多场景下仍然非常有用。理解和正确使用反射机制，可以提高代码的灵活性和可扩展性。在实际开发中，应该根据具体需求和性能考虑，合理使用反射机制。
Java基础篇：反射机制详解
热门推荐
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java反射机制及其作用
weixin_42416780的博客
10-13 1808
反射 1、反射的基本概念 反射库是一个提供了一系列丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序，能够分析类能力的程序称之为反射（reflection）。 通过反射能够将Java类中各个部分映射成为一个个Java对象，比如构造器、成员变量、方法。 2、反射的作用 Ⅰ. 反射最重要的用途就是开发各种通用框架，反射机制能够具有在运行时分析类的能力、在运行时查看对象。 Ⅱ. 反射的核心是JVM在运行时才动态加载类或调用方法/访问属性，它不需要事先（写代码的时候或编译期）知道运行对象是谁。 Ⅲ. 当
Java反射机制练习题
该博主太懒了，简介都不写
03-16 1490
使用反射可以获取私有属性和方法。但是需要注意，如果类中的私有属性或方法被定义为私有final的话，是无法通过反射来修改其值或调用其方法的。
Java 反射机制快速入门及常见方法全归纳。
yzh2776680982的博客
08-21 3096
▶Class也是类，因此也继承Object类▶Class类对象不是new出来的，而是系统创建的▶对于某个类的Class类对象,在内存中只有一份。因为类只加载一次▶每个类的实例都会记得自己是由哪个Class实例所生成▶通过Class对象可以完整地得到一个类的完整结构，通过一系列API▶Class对象是存放在堆的▶类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码，变量名，方法名，访问权限等等）▶常见方法▶代码示例▶基本概念。...
java反射机制原理详解
m0_56863607的博客
03-01 819
java 反射
java反射机制
Yoke
07-02 1万+
1. 什么是反射机制？ 首先大家应该先了解两个概念，编译期和运行期，编译期就是编译器帮你把源代码翻译成机器能识别的代码，比如编译器把java代码编译成jvm识别的字节码文件，而运行期指的是将可执行文件交给操作系统去执行，JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为ja...
java 反射机制
05-09
### Java反射机制深入理解 #### 一、反射机制概述 Java反射机制是一种强大的工具，它允许程序在运行时检查和操作任何类、方法、构造函数和字段等元素。这种能力对于构建灵活的应用程序和框架非常有用，特别是那些...
Java 反射机制实例详解
08-29
Java 反射机制实例详解 Java 反射机制实例详解是一种动态语言机制，允许在程序运行时加载、探知和使用编译期间完全不知道的类、生成其对象实体，调用其方法或者对属性设值。下面是 Java 反射机制实例详解的知识点：...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
利用java反射机制实现自动调用类的简单方法
09-01
Java反射机制是Java语言提供的一种强大功能，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在上述示例中，通过反射机制实现了动态调用类的方法，这种方式在某些场景下非常有用，比如插件...
Web前端开发（JS的快速入门）
最新发布
2401_88455976的博客
05-24 917
元素的底部，可改善显示速度外部的JS文件中，只包含JS代码，不包含<script>标签<script>标签不能自闭合<head><title>JS引入方式</title>-- 内部脚本 -->-- 外部脚本 --></head><body>
shader 圆形水波纹效果 threejs vue3
m0_65915285的博客
05-22 207
【代码】shader 圆形水波纹效果 threejs vue3。
JavaScript进阶(十二)
weixin_52047874的博客
05-23 769
都可以改变函数 内部的this指向.call和apply会调用函数，并且改变函数内部this指向.call和apply传递的参数不一样，call 传递参数aru1，aru2..形式 apply 必须数组形式[arg]bind不会调用函数，可以改变函数内部this指向call调用函数并且可以传递参数apply经常跟数组有关系.比如借助于数学对象实现数组最大值最小值bind不调用函数，但是还想改变this指向.比如改变定时器内部的this指向.
JavaScript对象继承
m0_63472757的博客
05-23 833
/ 子类通过原型链继承父类为了解决原型包含引用值导致的继承问题,一种叫作"盗用构造函数"的技术在开发社区流行起来(这种技术有时也称作"对象伪装"或"经典继承"). 基本思路很简单: 在子类构造函数中调用父类的构造函数 , 因为毕竟函数就是特定上下文中执行代码的简单对象,所以可以使用apply( )和call( )方法以新创建的对象为上下文执行构造函数,来看下面的例子://父类//子类//继承SuperType。
vite学习笔记
zxz86的博客
05-23 689
现代浏览器项目（Chrome >=61, Firefox >=60, Safari >=11）assetsInlineLimit: 4096, // 4KB以下资源内联。框架新项目（Vue3/React18/Svelte）极速启动：冷启动时间比传统工具快 10-100 倍。闪电热更新：HMR 更新速度不受项目规模影响。智能构建：生产环境使用 Rollup 打包。库开发（利用 Rollup 的纯净打包）.scss/.less 直接导入。微前端子应用（快速加载需求）模拟 CommonJS。
Java反射机制深入探索
"Java反射机制的解释" Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时检查和操作类、接口、字段和方法等对象。通过Java反射API（Java Reflection API），开发者可以在程序执行期间获取任何已知...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值