Java中的反射

发布于：2025-05-10 ⋅ 阅读:(10) ⋅ 点赞:(0)

目录

什么是反射

反射的核心作用

反射的核心类

反射的基本使用

获取Class对象

创建对象

操作字段（Field）

调用方法（Method）

反射的应用场景

反射的优缺点

优点

缺点

示例：完整反射操作

总结

什么是反射

能够获取类信息的能力叫做反射

反射的核心作用

反射的核心是 在运行时动态分析类或对象，而不是在编译时确定。主要功能包括：

  • 动态加载类（Class.forName("全限定类名")）

  • 获取类的结构信息（方法、字段、构造器、注解等）

  • 操作对象的属性和方法（包括私有成员）

  • 动态创建对象（即使构造器是 private 的）

  • 动态调用方法（包括私有方法）

反射的核心类

Java 反射主要通过以下类实现：

类/接口 作用
java.lang.Class 表示一个类或接口，是所有反射操作的入口
java.lang.reflect.Field 表示类的字段（成员变量），可获取或修改字段值
java.lang.reflect.Method 表示类的方法，可动态调用方法
java.lang.reflect.Constructor 表示类的构造方法，可动态创建对象
java.lang.reflect.Modifier 解析类、方法、字段的修饰符（如 public、private、static 等）

画图理解反射

反射的基本使用

获取Class对象

要使用反射，必须先获取类的 Class 对象。有 3 种方式：

// 方式1：类名.class
Class<Cat> clazz1 = Cat.class;

// 方式2：对象.getClass()
Cat cat = new Cat();
Class<?> clazz2 = cat.getClass();

// 方式3：Class.forName("全限定类名")（最常用）
Class<?> clazz3 = Class.forName("com.qcby.reflect.Cat");

创建对象

通过 Constructor 动态创建对象：

// 获取无参构造器（即使是 private 的也可以访问）
Constructor<?> constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(true); // 暴力反射，绕过 private 限制
Cat cat = (Cat) constructor.newInstance();

// 获取有参构造器
Constructor<?> constructor2 = clazz.getDeclaredConstructor(int.class, String.class);
Cat cat2 = (Cat) constructor2.newInstance(3, "Tom");

操作字段（Field）

获取和修改对象的字段值（包括私有字段）：

Field ageField = clazz.getDeclaredField("age");
ageField.setAccessible(true); // 访问私有字段

// 获取字段值
int age = (int) ageField.get(cat);
System.out.println(age); // 输出：3

// 修改字段值
ageField.set(cat, 5); // 把 cat 的 age 改为 5

调用方法（Method）

动态调用方法（包括私有方法）：

Method runMethod = clazz.getDeclaredMethod("run", String.class);
runMethod.setAccessible(true); // 访问私有方法

// 调用方法（相当于 cat.run("Jerry")）
runMethod.invoke(cat, "Jerry"); // 输出：Tom的猫正在追Jerry

反射的应用场景

  1. 框架开发（如 Spring 的依赖注入、Hibernate 的 ORM 映射）

  2. 动态代理（如 JDK 动态代理）

  3. 注解处理（如 @Autowired、@RequestMapping）

  4. 单元测试（Mock 对象）

  5. 动态加载类（如插件化开发）

反射的优缺点

优点

  • 灵活性高：可以在运行时动态操作类，实现高度解耦。

  • 突破访问限制：可以访问 private 成员，实现特殊需求（如序列化、反序列化）。

缺点

  • 性能较低：反射比直接调用方法慢（JVM 无法优化反射调用）。

  • 安全性问题：可以绕过访问控制，破坏封装性。

  • 代码可读性差：反射代码通常较难理解和维护。

示例：完整反射操作

package com.qcby.reflect;

public class Cat implements Jump,Run{
	private int age;
	public String name;
	protected String color;
	double height;
	
	public Cat(int age, String name, String color, double height) {
		this.age = age;
		this.name = name;
		this.color = color;
		this.height = height;
	}
	
	private Cat( ) {
		
	}
	
	Cat(String color){
		this.color = color;
	}
	
	public void run(String name) {
		System.out.println("小猫的名字叫"+name);
	}
	
	private int setAge(int age) {
		System.out.println("aa"+age);
		return age;
	}
	
	void flay() {
		System.out.println("猫不会飞");
	}
}


package com.qcby.reflect;

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

public class Test {
    public static void main(String[] args) throws Exception {
        // 反射获取类信息
        // 1. 使用正确的类名路径
        Class clazz = Class.forName("com.qcby.reflect.Cat");
        
        // 2. 获取类信息
        // 获取所有声明的字段（包括私有字段）
        Field[] fields = clazz.getDeclaredFields();
        System.out.println(Arrays.toString(fields));
        
        // 获取单个字段（使用getDeclaredField，返回Field对象）
        Field ageField = clazz.getDeclaredField("age");
        System.out.println(ageField);
        
        Field nameField = clazz.getDeclaredField("name");
        System.out.println(nameField);
        
        Field colorField = clazz.getDeclaredField("color");
        System.out.println(colorField);
        
        Field heightField = clazz.getDeclaredField("height");
        System.out.println(heightField);
        
        // 获取所有公共字段（仅public）
        Field[] fields1 = clazz.getFields();
        System.out.println(Arrays.toString(fields1));
        
        // 获取单个公共字段（仅public）
        Field nameField1 = clazz.getField("name");
        System.out.println(nameField1);
    }
}


package com.qcby.reflect;

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

public class Test1 {
    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("com.qcby.reflect.Cat"); 

        // 获取所有公共构造方法
        Constructor[] constructors = clazz.getConstructors();
        System.out.println(Arrays.toString(constructors));

        // 获取所有声明的构造方法（包括私有）
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        System.out.println(Arrays.toString(declaredConstructors));

        // 获取无参构造方法（需处理访问权限）
        Constructor constructor1 = clazz.getDeclaredConstructor();
        System.out.println(constructor1);

        // 获取带参数的构造方法
        Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
        System.out.println(constructor2);

        // 获取公共无参构造方法
        Constructor constructor3 = clazz.getConstructor(int.class, String.class, String.class, double.class);
        System.out.println(constructor3);
    }
}


package com.qcby.reflect;

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

public class Test2 {
    public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("com.qcby.reflect.Cat");
        
        // 获取所有声明的方法（包括私有方法）
        Method[] methods = clazz.getDeclaredMethods();
        System.out.println(Arrays.toString(methods));
        
        // 获取所有公共方法（包括继承的公共方法）
        Method[] methods2 = clazz.getMethods();
        System.out.println(Arrays.toString(methods2));
        
        // 根据方法名和参数类型获取方法
        Method runMethod1 = clazz.getDeclaredMethod("run", String.class);
        System.out.println(runMethod1);
        
        Method runMethod2 = clazz.getMethod("run", String.class);
        System.out.println(runMethod2);
        
        Method flyMethod1 = clazz.getDeclaredMethod("flay");
        System.out.println(flyMethod1);
    }
}

总结

特性 说明
动态性 运行时获取类信息，无需提前知道类的结构
灵活性 可以操作私有成员、动态创建对象、调用方法
用途广泛 框架开发、动态代理、注解处理、单元测试等
性能损耗 比直接调用满，不适合高频场景
安全性 可以绕过访问控制，需谨慎使用

反射是 Java 高级特性，合理使用可以极大增强程序的灵活性，但滥用会导致性能问题和代码难以维护。建议在框架开发、动态代理等场景使用，普通业务代码尽量避免。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布