java 反射

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量192 收藏 3
点赞数 5
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CCpwei/article/details/142655444
版权

允许程序在运行时访问和操作类的属性和方法。这使得 Java 在某些情况下更加灵活，能够动态地加载类、创建对象以及调用方法。

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

public class ReflectionExample {

    public static void main(String[] args) throws Exception {
        // 获取 Class 对象
        Class<?> clazz = Class.forName("com.example.MyClass");

        // 创建实例
        Constructor<?> constructor = clazz.getConstructor();
        Object instance = constructor.newInstance();

        // 访问字段
        Field field = clazz.getDeclaredField("myField");
        field.setAccessible(true); // 访问私有字段
        field.set(instance, "Hello Reflection");

        // 调用方法
        Method method = clazz.getDeclaredMethod("myMethod");
        method.setAccessible(true); // 访问私有方法
        method.invoke(instance);
    }
}

1. 获取 Class 对象

  • Class.forName(String className)：通过类名获取对应的 Class 对象。
  • MyClass.class：直接通过类名获取 Class 对象。
  • object.getClass()：通过对象获取其对应的 Class 对象。
package com.example;

public class MyClass {
    private String message;

    public MyClass() {
        this.message = "Hello, World!";
    }

    public void displayMessage() {
        System.out.println(message);
    }
}

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 1. 使用 Class.forName
            Class<?> clazz1 = Class.forName("com.example.MyClass");
            System.out.println("Class Name from forName: " + clazz1.getName());

            // 2. 使用 MyClass.class
            Class<MyClass> clazz2 = MyClass.class;
            System.out.println("Class Name from class literal: " + clazz2.getName());

            // 3. 使用 object.getClass()
            MyClass myObject = new MyClass();
            Class<?> clazz3 = myObject.getClass();
            System.out.println("Class Name from instance: " + clazz3.getName());

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}



//输出结果
Class Name from forName: com.example.MyClass
Class Name from class literal: com.example.MyClass
Class Name from instance: com.example.MyClass

2. 创建对象（调用构造器）

  • newInstance()：通过无参构造器创建类的实例（已被弃用，推荐使用 Constructor）。
  • Constructor 类：
    • getConstructor(Class<?>... parameterTypes)：获取公共构造器。
    • getDeclaredConstructor(Class<?>... parameterTypes)：获取声明的构造器（包括私有构造器）。
    • newInstance(Object... initargs)：通过构造器创建实例。
package com.example;

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

    // 无参构造器
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带参数的构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 私有构造器
    private Person(String name) {
        this.name = name;
        this.age = 25; // 默认年龄
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static Person createWithName(String name) throws Exception {
        Constructor<?> privateConstructor =     
        Person.class.getDeclaredConstructor(String.class);
        privateConstructor.setAccessible(true); // 允许访问私有构造器
        return (Person) privateConstructor.newInstance(name);
    }

}

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 1. 使用 newInstance()（已被弃用）
            Class<?> clazz = Class.forName("com.example.Person");
            Person person1 = (Person) clazz.newInstance();
            person1.display(); // 输出: Name: Unknown, Age: 0

            // 2. 获取公共构造器
            Constructor<?> publicConstructor = clazz.getConstructor(String.class, int.class);
            Person person2 = (Person) publicConstructor.newInstance("Alice", 30);
            person2.display(); // 输出: Name: Alice, Age: 30

            // 3. 通过私有构造器创建实例
            Person person3 = Person.createWithName("Bob");
            person3.display(); // 输出: Name: Bob, Age: 25

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 访问字段

  • getField(String name)：获取公共字段。
  • getFields() :获得所有公共字段，返回Field[]数组。
  • getDeclaredField(String name)：获取声明的字段（包括私有字段）。
  • getDeclaredFields()：获得声明的所有字段（包括私有字段），返回Field[]数组。
  • Field 类的方法：
    • get(Object obj)：获取字段的值。
    • set(Object obj, Object value)：设置字段的值。
    • setAccessible(true)：允许访问私有字段。
package com.example;

public class Car {
    public String brand;
    private int year;

    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public void display() {
        System.out.println("Brand: " + brand + ", Year: " + year);
    }
}

import java.lang.reflect.Field;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 创建 Car 实例
            Car car = new Car("Toyota", 2020);

            // 1. 获取公共字段
            Field brandField = Car.class.getField("brand");
            String brandValue = (String) brandField.get(car);
            System.out.println("Brand: " + brandValue); // 输出: Brand: Toyota

            // 2. 获取私有字段
            Field yearField = Car.class.getDeclaredField("year");
            yearField.setAccessible(true); // 允许访问私有字段
            int yearValue = (int) yearField.get(car);
            System.out.println("Year: " + yearValue); // 输出: Year: 2020

            // 3. 修改公共字段
            brandField.set(car, "Honda");
            car.display(); // 输出: Brand: Honda, Year: 2020

            // 4. 修改私有字段
            yearField.set(car, 2022);
            car.display(); // 输出: Brand: Honda, Year: 2022

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


//输出
Brand: Toyota
Year: 2020
Brand: Honda, Year: 2020
Brand: Honda, Year: 2022

4. 调用方法

  • getMethod(String name, Class<?>... parameterTypes)：获取公共方法。
  • getMethods()：获取所有公共方法，返回Method[]数组。
  • getDeclaredMethod(String name, Class<?>... parameterTypes)：获取声明的方法（包括私有方法）。
  • getDeclaredMethod()：获取所有声明的方法（包括私有方法）。返回Method[]数组。
  • Method 类的方法：
    • invoke(Object obj, Object... args)：调用方法。
    • setAccessible(true)：允许访问私有方法。
package com.example;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    private int subtract(int a, int b) {
        return a - b;
    }

    public void displayResult(int result) {
        System.out.println("Result: " + result);
    }
}

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 创建 Calculator 实例
            Calculator calculator = new Calculator();

            // 1. 获取所有公共方法
            Method[] publicMethods = Calculator.class.getMethods();
            System.out.println("Public Methods:");
            for (Method method : publicMethods) {
                System.out.println(method.getName());
            }

            // 2. 获取所有声明的方法（包括私有方法）
            Method[] allMethods = Calculator.class.getDeclaredMethods();
            System.out.println("\nAll Declared Methods:");
            for (Method method : allMethods) {
                System.out.println(method.getName());
            }

            // 3. 调用公共方法
            Method addMethod = Calculator.class.getMethod("add", int.class, int.class);
            int sum = (int) addMethod.invoke(calculator, 5, 3);
            System.out.println("\nSum: " + sum); // 输出: Sum: 8

            // 4. 调用私有方法
            Method subtractMethod = Calculator.class.getDeclaredMethod("subtract", int.class, int.class);
            subtractMethod.setAccessible(true); // 允许访问私有方法
            int difference = (int) subtractMethod.invoke(calculator, 5, 3);
            System.out.println("Difference: " + difference); // 输出: Difference: 2

            // 5. 调用公共方法并打印结果
            Method displayMethod = Calculator.class.getMethod("displayResult", int.class);
            displayMethod.invoke(calculator, sum); // 输出: Result: 8

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


//结果
Public Methods:
add
displayResult

All Declared Methods:
add
subtract
displayResult

Sum: 8
Difference: 2
Result: 8

 

风雨匆匆过
关注
Java反射技术详解及实例解析
08-18
Java反射技术是Java编程语言中的一个强大特性，它允许程序在运行时检查并操作类、接口、对象等的内部信息，包括但不限于类名、方法、字段等。这种能力使得Java程序具有高度的灵活性和动态性，是许多高级框架和库的...
Java反射技术详解
热门推荐
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是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 4971
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 1855
JAVA反射机制 JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。 Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制 功能 1、获得某个对象的属...
java反射调用get/set方法
吴名氏的博客
06-14 9万+
java反射调用get/set方法
Java反射
qq_45847507的博客
04-20 2526
Java反射
JAVA反射
Dgs的博客
06-30 1310
JDK 反射使用
Java反射介绍
派大星的博客
09-21 1508
总结介绍java反射基本知识，希望对java安全初学者有所帮助。
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
Java反射技术原理与用法实例分析
08-19
Java反射技术原理与用法实例分析 Java反射技术是Java语言中的一种动态语言技术，能够在运行时解析外部对象的信息。通过反射技术，可以动态地获取类以及类中的成员，并可以调用该类成员。 产生反射技术的需求： 在...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 721
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 667
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 482
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 762
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
深入理解Java反射机制
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。这一机制使得Java具有高度的灵活性和强大的功能，尤其在框架开发、插件系统、元数据处理等方面发挥着关键作用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值