Java重点：反射机制的使用

已于 2023-06-24 09:08:09 修改
阅读量3.3k 收藏 10
点赞数 6
文章标签： java 开发语言 jvm eclipse java-ee
于 2023-06-22 12:58:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74383330/article/details/131338994
版权

目录

一、概念

二、类类

1、类类的获取方式

1）类名.Class

2）对象.getClass()

3）Class.forName()

三、反射实例化

1、调用一个公有的无参构造方法

2、调用一个公有的一个参构造方法

3、调用一个公有的两个参构造方法

4、调用一个私有的一个参构造方法

四、反射：方法调用

1、公有无参

2、公有有参

3、私有有参

完整代码：

五、反射：读写属性

一、概念

J2EE中的反射（Reflection）是指在程序运行期间访问、检测和修改自身的状态或行为。通过反射，可以动态地获取一个类的所有成员变量、方法、构造函数等信息，并且可以在运行时调用这些成员。在J2EE中，反射可以方便地实现一些框架、ORM工具，以及其他动态性能要求的应用程序。

什么是反射？

反射（Reflection）是一种在运行时动态地获取和操作对象的能力，它允许程序通过对象的类类型来了解对象的成员和方法，并且可以在运行时调用这些成员和方法。反射可以用于许多目的，例如在运行时动态加载类、实例化对象、查看和修改对象的属性和方法、调用私有方法和构造函数，等等。在Java中，反射通过java.lang.reflect包中的类和接口来实现。反射的优点是可以使我们的代码更加灵活和动态，但是反射的开销比较大，因此在性能要求较高的情况下，应该谨慎使用。

总的来说：反射Java语言中的一种机制，通过这种机制可以动态的实例化对象、读写属性、调用方法

二、类类

在Java反射（reflection）中，Class类被称为“类类”（class of class），因为它代表了JVM中的一个类。每个Java类在内存中都有一个对应的Class类实例对象，可以通过Java的反射机制获取。通过这个实例，我们可以动态地获取、创建、操作一个类的各种元数据（如属性、方法、注解等），并可以在程序运行时动态地创建、修改该类的对象。通过反射，我们可以实现更加灵活和动态的编程方式，可以在编码阶段不确定访问的类和方法，直到运行时才确定需要获取和调用的类和方法。

1、类类的获取方式

1. Object类中的getClass()方法：可以获取一个对象所属的类。

2. 类名.class：直接通过类名这种语法形式获取一个类的Class实例对象。

3. Class.forName(String className)：通过类的全限定名获取Class实例对象，需要处理ClassNotFoundException异常。

这些方式均可以获得一个Java类的Class实例对象，从而可以利用反射机制获取该类的一系列信息，如属性、方法、构造方法、注解等。

1）类名.Class

在开始示例的前期准备工作我们写一个类（Class）

package com.tgq.reflect;

/**
 * 一个类
 * 
 * @author tgq
 *
 */
public class Student {
	private String sid;

	private String sname;

	public Integer age;

	static {
		System.out.println("加载进jvm中！");
	}

	public Student() {
		super();
		System.out.println("调用无参构造方法创建了一个学生对象");
	}

	public Student(String sid) {
		super();
		this.sid = sid;
		System.out.println("调用带一个参数的构造方法创建了一个学生对象");
	}

	public Student(String sid, String sname) {
		super();
		this.sid = sid;
		this.sname = sname;
		System.out.println("调用带二个参数的构造方法创建了一个学生对象");
	}

	@SuppressWarnings("unused")
	private Student(Integer age) {
		System.out.println("调用Student类私有的构造方法创建一个学生对象");
		this.age = age;
	}

	public String getSid() {
		return sid;
	}

	public void setSid(String sid) {
		this.sid = sid;
	}

	public String getSname() {
		return sname;
	}

	public void setSname(String sname) {
		this.sname = sname;
	}

	public void hello() {
		System.out.println("你好！我是" + this.sname);
	}

	public void hello(String name) {
		System.out.println(name + "你好！我是" + this.sname);
	}

	@SuppressWarnings("unused")
	private Integer add(Integer a, Integer b) {
		return new Integer(a.intValue() + b.intValue());
	}
}

编写好一个类之后我们开始调用方法进行拿去：代码示例

package com.tgq.reflect;

/**
 * 类类的获取方式： 1、类名.Class 2、对象.getClass(); 3、Class.forName();
 * 
 * @author tgq
 *
 */
public class Demo_01 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {

		// 1、类名.Class
		Class c1 = Student.class;
		System.out.println(c1);

	}
}

输出结果：

2）对象.getClass()

package com.tgq.reflect;

/**
 * 类类的获取方式： 1、类名.Class 2、对象.getClass(); 3、Class.forName();
 * 
 * @author tgq
 *
 */
public class Demo_01 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {

		// 1、类名.Class
		// Class c1 = Student.class;
		// System.out.println(c1);
		
		// 2、对象.getClass();
		Student student = new Student();
		Class c2 = student.getClass();
		System.out.println(c2);

	}
}

输出结果：

3）Class.forName()

package com.tgq.reflect;

/**
 * 类类的获取方式： 1、类名.Class 2、对象.getClass(); 3、Class.forName();
 * 
 * @author tgq
 *
 */
public class Demo_01 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {

		// 1、类名.Class
		// Class c1 = Student.class;
		// System.out.println(c1);

		// 2、对象.getClass();
		// Student student = new Student();
		// Class c2 = student.getClass();
		// System.out.println(c2);

		// 3、Class.forName();
		Class c3 = Class.forName("com.tgq.reflect.Student");
		System.out.println(c3);
	}
}

输出结果：

三、反射实例化

在Java中，可以使用反射来实例化一个类。具体实现可以通过Class类的newInstance()方法或者Constructor类的newInstance()方法来实现。

三个常用的方法：getConstructor ()，getDeclaredConstructor () ，newInstance() 。

一切的反射从类类开始

1、调用一个公有的无参构造方法

public class Demo_02 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {
		// 一切反射从类类开始
		// 不管是哪一种获取类类的方法都是可以的
		// Class c1 = Class.forName("com.tgq.reflect.Student");
		// Student student = new Student();
		// Class c1 = student.getClass();
		Class c1 = Student.class;
		/*
		 * 1、调用一个无参构造器反射实例化： 如果没有无参构造器是会报错的
		 */
		Student stu1 = (Student) c1.newInstance();
		System.out.println(stu1);


	}
}

输出结果：

2、调用一个公有的一个参构造方法

public class Demo_02 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {
		// 一切反射从类类开始
		// 不管是哪一种获取类类的方法都是可以的
		// Class c1 = Class.forName("com.tgq.reflect.Student");
		// Student student = new Student();
		// Class c1 = student.getClass();
		Class c1 = Student.class;
		/*
		 * 1、调用一个无参构造器反射实例化： 如果没有无参构造器是会报错的
		 */
		Student stu1 = (Student) c1.newInstance();
		System.out.println(stu1);

		/*
		 * 调用有参构造器必须要实例化构造器对象 2、调用一个有一个参数的构造器：getConstructor == 获取构造器对象
		 * 
		 * parameterTypes:代表了参数的类别Class
		 */
		Constructor con1 = c1.getConstructor(String.class);
		Student stu2 = (Student) con1.newInstance("s1");
		System.out.println(stu2);

		

	}
}

输出结果：

3、调用一个公有的两个参构造方法

public class Demo_02 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {
		// 一切反射从类类开始
		// 不管是哪一种获取类类的方法都是可以的
		// Class c1 = Class.forName("com.tgq.reflect.Student");
		// Student student = new Student();
		// Class c1 = student.getClass();
		Class c1 = Student.class;
		/*
		 * 1、调用一个无参构造器反射实例化： 如果没有无参构造器是会报错的
		 */
		Student stu1 = (Student) c1.newInstance();
		System.out.println(stu1);

		/*
		 * 调用有参构造器必须要实例化构造器对象 2、调用一个有一个参数的构造器：getConstructor == 获取构造器对象
		 * 
		 * parameterTypes:代表了参数的类别Class
		 */
		Constructor con1 = c1.getConstructor(String.class);
		Student stu2 = (Student) con1.newInstance("s1");
		System.out.println(stu2);

		/*
		 * 3、调用两个参数的构造器实例化
		 */
		Constructor con2 = c1.getConstructor(String.class, String.class);
		Student stu3 = (Student) con2.newInstance("s1", "sb");
		System.out.println(stu3);

	}
}

输出结果：

4、调用一个私有的一个参构造方法

public class Demo_02 {
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) throws Exception {
		// 一切反射从类类开始
		// 不管是哪一种获取类类的方法都是可以的
		// Class c1 = Class.forName("com.tgq.reflect.Student");
		// Student student = new Student();
		// Class c1 = student.getClass();
		Class c1 = Student.class;
		/*
		 * 1、调用一个无参构造器反射实例化： 如果没有无参构造器是会报错的
		 */
		Student stu1 = (Student) c1.newInstance();
		System.out.println(stu1);

		/*
		 * 调用有参构造器必须要实例化构造器对象 2、调用一个有一个参数的构造器：getConstructor == 获取构造器对象
		 * 
		 * parameterTypes:代表了参数的类别Class
		 */
		Constructor con1 = c1.getConstructor(String.class);
		Student stu2 = (Student) con1.newInstance("s1");
		System.out.println(stu2);

		/*
		 * 3、调用两个参数的构造器实例化
		 */
		Constructor con2 = c1.getConstructor(String.class, String.class);
		Student stu3 = (Student) con2.newInstance("s1", "sb");
		System.out.println(stu3);

		/*
		 * 4、调用一个私有的带一个参数的构造器实例化： getConstructor只能获取公有的构造器对象
		 *
		 * getDeclaredConstructor：获取私有的构造器对象
		 */
		Constructor con3 = c1.getDeclaredConstructor(Integer.class);
		// 打开私有的访问权限
		con3.setAccessible(true);
		Student stu4 = (Student) con3.newInstance(1);
		System.out.println(stu4);

	}
}

输出结果：

四、反射：方法调用

1、公有无参

public class Demo_03 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;
		// 1、反射调用 无参方法
		Student s = (Student) c.newInstance();
		// 反射调用无参方法，先获取到方法对象
		// name:方法名
		// parameterTypes：调用这个方法要传的参数类型
		Method m1 = c.getMethod("hello");
		// invoke:方法的返回值
		// obj:类示例
		// args:参数值
		Object invoke = m1.invoke(s);
		System.out.println(invoke);

		
	}
}

输出结果：

2、公有有参

public class Demo_03 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;
		// 1、反射调用 无参方法
		Student s = (Student) c.newInstance();
		// 反射调用无参方法，先获取到方法对象
		// name:方法名
		// parameterTypes：调用这个方法要传的参数类型
		Method m1 = c.getMethod("hello");
		// invoke:方法的返回值
		// obj:类示例
		// args:参数值
		Object invoke = m1.invoke(s);
		System.out.println(invoke);

		// 2、调用有参方法
		Method m2 = c.getMethod("hello", String.class);
		Object invoke2 = m2.invoke(s, "asdfghjk");
		System.out.println(invoke2);

	}
}

输出结果：

3、私有有参

public class Demo_03 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;
		// 1、反射调用 无参方法
		Student s = (Student) c.newInstance();
		// 反射调用无参方法，先获取到方法对象
		// name:方法名
		// parameterTypes：调用这个方法要传的参数类型
		Method m1 = c.getMethod("hello");
		// invoke:方法的返回值
		// obj:类示例
		// args:参数值
		Object invoke = m1.invoke(s);
		System.out.println(invoke);

		// 2、调用有参方法
		Method m2 = c.getMethod("hello", String.class);
		Object invoke2 = m2.invoke(s, "asdfghjk");
		System.out.println(invoke2);


		// 3、调用有参私有的方法
		Method m3 = c.getDeclaredMethod("add", Integer.class, Integer.class);
		// 打开私有权限
		m3.setAccessible(true);
		Object invoke3 = m3.invoke(s, 1, 2);
		System.out.println(invoke3);
	}
}

输出结果：

完整代码：

package com.tgq.reflect;

import java.lang.reflect.Method;

/**
 * 反射动态方法的调用
 * 
 * @author tgq
 *
 */
public class Demo_03 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;
		// 1、反射调用 无参方法
		Student s = (Student) c.newInstance();
		// 反射调用无参方法，先获取到方法对象
		// name:方法名
		// parameterTypes：调用这个方法要传的参数类型
		Method m1 = c.getMethod("hello");
		// invoke:方法的返回值
		// obj:类示例
		// args:参数值
		Object invoke = m1.invoke(s);
		System.out.println(invoke);

		// 2、调用有参方法
		Method m2 = c.getMethod("hello", String.class);
		Object invoke2 = m2.invoke(s, "asdfghjk");
		System.out.println(invoke2);


		// 3、调用有参私有的方法
		Method m3 = c.getDeclaredMethod("add", Integer.class, Integer.class);
		// 打开私有权限
		m3.setAccessible(true);
		Object invoke3 = m3.invoke(s, 1, 2);
		System.out.println(invoke3);
	}
}

五、反射：读写属性

通过Field类的get()和set()方法来实现。

拿到我们所有的属性：


public class Demo_04 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;

		Student stu = new Student("1", "1A");
		// 我们把age设置一个值
		stu.age = 18;
		// System.out.println(stu.getSid());
		
		// 获取对象中全部的属性
		Field[] fields = c.getDeclaredFields();
		// 遍历
		for (Field f : fields) {
			// 因为sid、sname是私有的，所以我们要打开私有权限
			f.setAccessible(true);
			// 获取所有属性
			System.out.println(f.getName() + ":" + f.get(stu));
		}

	}
}

输出结果：

我们进行设置属性值：


public class Demo_04 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;

		Student stu = new Student("1", "1A");
		// 我们把age设置一个值
		stu.age = 18;
		// System.out.println(stu.getSid());

		// 拿到属性
		Field snamefield = c.getDeclaredField("sname");
		// 打开权限
		snamefield.setAccessible(true);
		// 进行设置
		snamefield.set(stu, "2B");
		
		// 获取对象中全部的属性
		Field[] fields = c.getDeclaredFields();
		// 遍历
		for (Field f : fields) {
			// 因为sid、sname是私有的，所以我们要打开私有权限
			f.setAccessible(true);
			// 获取所有属性
			System.out.println(f.getName() + ":" + f.get(stu));
		}

	}
}

输出结果：

完整代码：

package com.tgq.reflect;

import java.lang.reflect.Field;

/**
 * 反射：读写属性
 * 
 * @author tgq
 *
 */
public class Demo_04 {
	public static void main(String[] args) throws Exception {
		Class c = Student.class;

		Student stu = new Student("1", "1A");
		// 我们把age设置一个值
		stu.age = 18;
		// System.out.println(stu.getSid());

		// 拿到属性
		Field snamefield = c.getDeclaredField("sname");
		// 打开权限
		snamefield.setAccessible(true);
		// 进行设置
		snamefield.set(stu, "2B");

		// 获取对象中全部的属性
		Field[] fields = c.getDeclaredFields();
		// 遍历
		for (Field f : fields) {
			// 因为sid、sname是私有的，所以我们要打开私有权限
			f.setAccessible(true);
			// 获取所有属性
			System.out.println(f.getName() + ":" + f.get(stu));
		}

	}
}

无法自律的人
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
Java通过反射机制动态设置对象属性值的方法
09-01
下面小编就为大家带来一篇Java通过反射机制动态设置对象属性值的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【Java】反射基础(Class类）
摸鱼小小虫的博客
05-27 713
主要介绍反射的基础Class类、以及它的内部类Field类、Method类。以及简单介绍了反射。
从初学者到专家：Java反射的完整指南
LHY537200的博客
03-18 3219
反射是Java语言中的一项强大特性，它允许程序在运行时动态地获取、操作和修改类、对象、字段和方法的信息。通过反射，我们可以实现灵活的类实例化、字段访问和方法调用，以及处理注解和实现动态代理等功能。然而，反射的使用应谨慎，需要平衡灵活性、性能和安全性，并注意其局限性和注意事项。总而言之，反射为Java开发者提供了强大的工具，使得程序可以在运行时动态地适应不同的需求和场景。
Java 反射详解和使用
m0_58375976的博客
04-28 7557
反射(Reflection)机制是Java语言特性之一，是Java被视为动态(或准动态)语言的一个关键特性；
java反射机制原理详解.docx
07-02
java.lang.Class:是反射的源头 我们创建一个类，通过编译，生成对应的.calss文件，之后使用java.exe加载(jvm的类加载器)此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在缓存区，那么这个运行时类的本身就是一个class的实例 每一个运行时类只加载一次 有了Class实例以后，我们才可以进行如下的操作: o创建对应的运行时类的对象(重点) o可以获取对象的运行时类的完整结构（属性、方法、构造器、内部类、、、）（理解） o调用对应的运行时类的指定的结构（属性、方法）（重点） 在反射以前，如何创建一个类的对象，并调用其中的方法属性
Java反射机制重点总结
12-22
文章目录Java ReflectionJava反射机制提供的功能Java反射相关的主要APIjava.lang.Class类Class类的核心要点Class类的重要API实例实例化Class类对象(四种方法)创建类对象并获取类的完整结构获取Class对象后创建类的对象通过反射调用类的完整结构获取实现的全部接口获取所继承的父类获取全部的构造器获取全部的方法获取全部的属性获取Annotation相关获取泛型相关获取类所在的包调用指定方法调用指定属性总结说明 Java Reflection Reflection（反射）是被视为动态语言的关键，反射机制 允许程序在执行期借助于Reflection AP
Java反射-调用方法
热门推荐
as you know, nlp is fantasitc!
05-18 1万+
调用方法与访问字段类似， 通过Class实例的方法获得Method实例 getMethod()、getDeclaredMethod()、getMethods()、getDeclaredMethods()（这里的方法与获得Field字段的时候的用法是一致的） 通过Method实例可以获得有关方法的信息 getName()、getReturnTypes()、getParameterTypes()、getModifiers() (方法的名字、返回类型、参数类型、修饰符) 通过Method实例调用某个对象的方法
JAVA反射之调用方法
justlpf的专栏
01-19 2985
的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。如果获取到的Method表示一个静态方法，调用静态方法时，由于无需指定实例对象，所以。使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法（如果存在）。先得到 Method 对象 然后再调用 invoke 方法。对象时，就可以对它进行调用。获取该方法实例，但直接对其调用将得到一个。，不同的bit表示不同的含义。实例时，调用的方法到底是哪个？：返回方法的修饰符，它是一个。对象，同样的，可以通过。
java反射的基本使用方法
qq_23921815的博客
02-24 2711
Java反射
Java 反射使用大全
朱豪凯的博客
06-10 5862
好多年前自己记的关于Java反射的笔记，这么些年下来，自己用到反射的时候就看这一份就够了。但是笔记以文件形式存放不方便，所以将其放到CSDN中，也希望能给更多小伙伴带来帮助。
Java|反射之调用方法
weixin_67497686的博客
03-05 532
我们已经能通过Class实例获取所有Field对象，同样的，可以通过Class实例获取所有Method信息。Class类提供了以下几个方法来获取MethodpublicMethodMethodpublicMethodMethod---------------------------------------获得方法与获得字段是类似的----------------------------------------上述代码首先获取Student的Class实例，然后，分别获取public方法、继承的。
java反射机制
06-24
该文件有如何动态加载类,动态获得属性,动态调用方法,动态创建对象等
JavaDemo:Java相关演示代码实现
04-06
Java演示 Java相关演示代码实现 ##针对对象 类的继承 类的扩展 异常 ##泛型与容器 泛型 列表和数值 地图和集合 堆和优先重点 通用容器类 ##并发 并发包 并发容器 初步任务 同步与协作 ##动态与函数式编程 反射 注解 动态代理 类加载机制 函数式编程
JAVA的反射机制与动态代理.pdf
02-02
那个最近想看看Spring AOP的动态代理到底是个咋回事，特地学习了一下，写了个文档。 本文档先讲解了JDK的反射机制，然后是Proxy的动态代理、CGLIB的动态代理，因为这些是Spring AOP的底层技术，清楚了它们，你就更能够理解Spring AOP是如何工作的。在文档的最后简要写了Spring AOP的使用，因为这不是重点，网上Spring AOP的例子很多，本文档是为了给还不是十分清楚Spring AOP是如何工作的同学看的，希望有点儿启发作用！嘿嘿！
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 344
都是符合我们的预期的。
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 421
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1445
c++中string的模拟实现，面试必会知识点
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 550
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 614
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
java反射机制的使用
05-17
Java反射机制是指在运行时动态地获取类的信息并操作类的属性、方法和构造方法，而无需在编译时确定这些信息。Java反射机制通过以下步骤来实现： 1. 获取Class对象：使用Class类中的静态方法获取类的Class对象，例如： ``` Class<?> clazz = Class.forName("com.example.MyClass"); ``` 2. 获取类的构造方法：使用Class类中的getConstructor()或getDeclaredConstructor()方法获取类的构造方法，例如： ``` Constructor<?> constructor = clazz.getConstructor(String.class, int.class); ``` 3. 创建类的实例：使用构造方法创建类的实例，例如： ``` Object obj = constructor.newInstance("example", 123); ``` 4. 获取类的属性：使用Class类中的getField()或getDeclaredField()方法获取类的属性，例如： ``` Field field = clazz.getField("name"); ``` 5. 修改类的属性：使用Field类中的set()方法修改类的属性，例如： ``` field.set(obj, "newName"); ``` 6. 获取类的方法：使用Class类中的getMethod()或getDeclaredMethod()方法获取类的方法，例如： ``` Method method = clazz.getMethod("doSomething", String.class); ``` 7. 调用类的方法：使用Method类中的invoke()方法调用类的方法，例如： ``` method.invoke(obj, "someArg"); ``` Java反射机制的应用场景包括框架开发、动态代理、注解处理器等。需要注意的是，反射机制虽然灵活，但由于是在运行时进行的，因此效率较低，而且容易出现类型不匹配、访问权限等问题，应谨慎使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无法自律的人

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

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

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

打赏作者

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

抵扣说明：

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

余额充值