java基础：反射

已于 2022-02-15 08:49:54 修改
阅读量86 收藏
点赞数
分类专栏： 大杂烩 文章标签： java
于 2021-10-15 21:15:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalala_dxf/article/details/120784849
版权

反射

1、概述

1.1 定义

在运行程序的过程中，动态获取一个类中的基本信息

2、Class类型

2.1 定义

java.lang.Class是API中提供的一个类，可以表示java中所有的类型，包括基本类型和引用类型。

2.2 使用Class类对向表示不同类型

表示基本类型

//对象c表示int类型
CLass c = int.class;
//判断对象c是不是基本类型
System.out.println(c.isPrimitive());
//获取对象c所代表的类型的名字
System.out.println(c.getName());

表示类类型

假设有个Student类

//对象c代表Student类型
Class c = Student.class;
//获取Student类的全限定名
System.out.println(c.getName());

表示接口类型

//对象c表示List接口类型
Class c = List.class;
//判断对象c是不是接口类型
System.out.prinln(c.isInterface());
System.out.println(c.getName());

表示数组类型

Class c;
c = Student[].class;
//判断对象c是不是数组类型
System.out.println(c.isArray());
//获取数组的简单名
System.out.println(c.getSimpleName());
//获取该数组具体类型是什么
System.out.println(c.getComponentType().getSimpleName());

运行结果
true
Student[]
Student

3、获取Class对象的方式

总的来说有下面的三种方式，但不同类型对象使用的方式有些许区别
方式一：使用类型名称直接获取**（最常用）**
方式二：使用Class类中的静态方法forName获取
方式三：使用对象调用getClass方法获取

获取基本类型的Class对象：
只有一种方式：类型名称直接获取

Class c = int.class;

获取接口类型的Class对象：
两种方式：
方式1:类型名称直接获取

Class c = Action.class;

方式2：使用Class类中的静态方法forName获取

Class c = Class.forName("全限定名");

获取数组类型的Class对象：
两种方式：类型名称直接获取
方式1：

Class c = int[].class;

方式2：使用对象调用getClass方法获取

int[] arr = new int[4];
Class c = arr.getClass();

获取类类型的Class对象
三种方式
方式1：类型名称直接获取

Class c = Student.class;

方式2：使用Class类中的静态方法forName获取

Class c = Class.forName("全限定名");

方式3：使用对象调用getClass方法获取

Student stu = new Student();
Class c3 = stu.getClass();

3、获取类中信息的方法

3.1 获取类的基本信息

方法名功能补充
getName()获取类的全限定名
getSimpleName()获取类的简单名
getPackage()获取所属的包获取包名：getPackage().getName()
getModifiers()返回此类或接口的修饰符的整数编码常和Modifier类中的toString()方法搭配使用，可以获取修饰符名称
getSuperclass()获取父类型搭配getName使用获取父类类名
getInterfaces()返回的是一个数组。返回由该对象表示的类或接口实现的接口搭配Arrays工具类中的toString方法使用
isAssignableFrom()判断类对象表示的类或接口是否与由指定的Class 类表示的类或接口相同

例如：
以下均以Student类为例进行操作

package blog_1.reflect_0;

interface Action{
	void run();
}

interface Mark{
	void star();
}
public class Student implements Action,Mark{
	private String name; //私有 
	int age; //普通
	public static int num; //静态
	
	public Student()	{}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//定义普通方法
	public String sayHello(String name) {
		return "hello!" + name;
	}

	//重写接口中的方法
	@Override
	public void star() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}
}


package blog_1.reflect_0;

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

interface Action{
	void run();
}

interface Mark{
	void star();
}
public class Student implements Action,Mark{
	private String name; //私有 
	int age; //普通
	public static int num; //静态
	
	public Student()	{}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//定义普通方法
	public String sayHello(String name) {
		return "hello!" + name;
	}

	//重写接口中的方法
	@Override
	public void star() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}
}

@SuppressWarnings("all")
class Demo01{
	public static void main(String[] args) throws Exception{
		//这里通过创建学生对象调用getClass()方法获取Class对象
		Student stu = new Student();
		Class c = stu.getClass();
		
		//获取类的全限定名
		System.out.println(c.getName());
		//获取类的简单类名
		System.out.println(c.getSimpleName());
		//获取类所属包的名字
		System.out.println(c.getPackage().getName());
		//获取类的修饰符
		System.out.println(c.getModifiers()); //这里获取的是编码
		System.out.println(Modifier.toString(c.getModifiers())); //间接获取修饰符名
		//获取类的父类型的名字
		System.out.println(c.getSuperclass().getName());
		//获取类实现的所有接口
		System.out.println(Arrays.toString(c.getInterfaces()));
		
		//判断对象所属类型是不是c的父类型
		Class c1 = Object.class;
		Class c2 = Action.class;
		Class c3 = Mark.class;
		Class c4 = String.class;
		
		System.out.println(c1.isAssignableFrom(c)); //判断c1是不是c代表类型的父类型
		System.out.println(c2.isAssignableFrom(c));
		System.out.println(c3.isAssignableFrom(c));
		System.out.println(c4.isAssignableFrom(c));
		
	}
}

结果：
blog_1.reflect_0.Student
Student
blog_1.reflect_0
1
public
java.lang.Object
[interface blog_1.reflect_0.Action, interface blog_1.reflect_0.Mark]
true
true
true
false

3.2 获取类中声明的属性

java中将属性类型都打包到了java.lang.reflect.Field这个包中。

获取类中public修饰的属性，包括继承过来的public属性

方法功能
Field[] getFields()返回一个数组，获取所有权限为public的属性
Field getField(String name)返回一个Field对象，获取权限为public的指定对象

获取类中声明的属性（含私有的）但是不能获取从父类中继承的属性

方法功能
Filed[] getDeclaredFields()返回Class对表示的所有实体的成员变量，但不包括继承过来的属性
Field getDeclaredField(String name)返回Class对象所表示的类或接口的指定已声明成员变量

例如：

public static void main(String[] args) {
		Class c = Student.class;
		
		//获取类中所有声明的属性，不包括从父类继承过来的
		Field[] fields = c.getDeclaredFields();
		
		for(Field f : fields) {
			System.out.println("属性的修饰符：" + Modifier.toString(c.getModifiers()));
			System.out.println("属性的类型：" + f.getType().getName());
			System.out.println("属性的名称：" + f.getName());
			System.out.println("-----------------");
		}
	}

结果：
属性的修饰符：public
属性的类型：java.lang.String
属性的名称：name
--------------------
属性的修饰符：public
属性的类型：int
属性的名称：age
-----------------
属性的修饰符：public
属性的类型：int
属性的名称：num
-----------------

3.3 获取类中声明的方法

获取当前类中的public方法，包含从父类中继承的public方法

方法名功能
Method[] getMethods()返回一个数组，获取所有权限为public的方法
Method getMethod(String name,Class<?>…parameterTypes)返回method对象，获得权限为public的指定方法

获取当前类中声明的方法（包含私有的），但不能获取父类中继承过来的方法

方法名功能
method[] getDeclaredMethods()返回Method类型数组，返回所有方法，不包括从父类继承过来的
Method getDeclaredMethod(String name,Class<?>…parameterTypes)返会Method对象，返回指定公共成员方法，name是指定方法名称，parameterTypes是指定方法参数类型

其他一些相关方法

方法名功能
getReturnType()获取方法返回类型
getParameterTypeCount()获取方法中参数个数
getExceptionTypes()获取方法抛出异常类型
getParameterTypes()获取参数列表

例如：

	public static void main(String[] args) {
		Student stu = new Student();
		Class c = stu.getClass();
		
		Method[] methods = c.getDeclaredMethods();
		for(Method m : methods) {
			//获取方法的修饰符
			System.out.println(Modifier.toString(m.getModifiers()));
			//获取方法的返回类型
			System.out.println(m.getReturnType().getSimpleName());
			//获取方法的名字
			System.out.println(m.getName());
			System.out.println("方法参数个数：" + m.getParameterCount());
			//获取方法的参数列表
			Class<?>[] paramArr = m.getParameterTypes();
			//输出方法的参数列表
			System.out.println("\t" + Arrays.toString(paramArr));
			
			//获取方法所抛出的异常类型
			Class<?>[] exceptionArr = m.getExceptionTypes();
			System.out.println("方法抛出异常个数" + exceptionArr.length);
			
			//输出方法所抛出的异常列表
			System.out.println("\t" + Arrays.toString(exceptionArr));
			System.out.println("----------------------------");
		}
	}

public
void
run
方法参数个数：0
[]
方法抛出异常个数0
[]
----------------------------
public
String
getName
方法参数个数：0
[]
方法抛出异常个数0
[]
----------------------------
public
void
setName
方法参数个数：1
[class java.lang.String]
方法抛出异常个数0
[]
----------------------------
public
void
star
方法参数个数：0
[]
方法抛出异常个数0
[]
----------------------------
public
String
sayHello
方法参数个数：1
[class java.lang.String]
方法抛出异常个数0
[]
----------------------------

java.lang.reflect.Method表示类中的方法

3.4 获取类中声明的构造器

获取当前类中的public构造器

方法名功能
public Constructor<?>[] getConstructors()返回一个数组，数组中是Constructor对象
public Constructor getConstructor(Class<?>…parameterTypes)返回一个指定的构造器对象，class是类名，parameterTypes是参数类型

获取当前类汇总所有的构造器，包含私有的

方法名功能
public Constructor<?>[] getDeclaredConstructors()返回所有 构造器对象
public Constructor getDeclaredConstructors(Class<?> …parameterTypes)返回指定的构造器对象
public static void main(String[] args) {
		Student stu = new Student();
		Class c= stu.getClass();
		
		//获取类中所有的public构造器
		Constructor[] constructors = c.getConstructors();
		for(Constructor constructor : constructors) {
			//构造器的修饰符
			System.out.println(Modifier.toString(constructor.getModifiers()));
			//构造器的名字
			System.out.println(constructor.getName());
			
			//构造器的参数列表
			Class[] paramList = constructor.getParameterTypes();
			System.out.println(java.util.Arrays.toString(paramList));
			
			//构造器的抛出异常
			Class[] exceptionList = constructor.getExceptionTypes();
			System.out.println(java.util.Arrays.toString(exceptionList));
			
			System.out.println("------------------------");
		}
	}

结果：
public
blog_1.reflect_0.Student
[]
[]
------------------------
public
blog_1.reflect_0.Student
[class java.lang.String, int]
[]
------------------------

4、反射访问和赋值属性

访问类中属性
1、非私有非静态属性
set(对象，属性值 ) get(对象)

2、非静态私有属性
先使用setAccessible(true)方法获取访问权限 再使用set(对象，属性值）赋值，通过 get(对象)方法获取

3、静态属性 set(null,属性值) get(null);

public static void main(String[] args) throws Exception {
		Student stu = new Student();
		Class c = stu.getClass();
		
		//获取类中名字叫name的私有属性
		Field f1 = c.getDeclaredField("name");
		//设置私有属性可以被访问，否则会报错
		f1.setAccessible(true);
		
		
		//使用反射的方式给指定对象的name属性赋值为tom
		f1.set(stu, "tom");
		//使用反射的方式获取这个属性的值
		System.out.println(f1.get(stu));
		
		System.out.println("-----------------");
		
		//获取类中名字叫age的属性
		Field f2 = c.getDeclaredField("age");
		f2.set(stu, 20);
		System.out.println(f2.get(stu));
		System.out.println("-----------------");
		
		Field f3 = c.getDeclaredField("num");
		//用反射的方式，给静态属性num赋值，不需要对象
		f3.set(null, 99);
		System.out.println(f3.get(null));
		
	}

结果：
tom
-----------------
20
-----------------
99

5、反射调用方法

反射调用方法的方法：
public Object invoke(Object obj,Object…args)

obj是指要调用方法的对象，静态方法就传null
args表示要调用的方法的参数列表

访问类中方法
1、非静态方法 invoke (obj,params.class)
2、静态方法 invoke(null,params.class)
3、静态无参 invoke(null,null)

public static void main(String[] args) throws Exception{
		Student stu = new Student();
		Class c = stu.getClass();
		
		//获取类中的toString方法，没有参数，这是从父类中继承的方法
		Method m1 = c.getMethod("toString", null); //toString是要获取的方法的名字，后面一个指定是参数
		//利用反射的方式调用stu对象中的这个方法，没有参数，并接收执行结果
		Object result = m1.invoke(stu, null); //括号内前一个参数是对象名，后一个是参数名
		
		//输出执行结果
		System.out.println(result);
		
		System.out.println("-------------");
		
		//获取类中的sayHello方法，需要一个String类型的参数
		Method m2 = c.getMethod("sayHello", String.class);
		
		//通过反射的方式调用stu对象中的而这个方法，参数是“tom”,并接收执行结果
		result = m2.invoke(stu, "tom");
		
		System.out.println(result);
	}

6、反射创建对象

反射调用类中无参构造器创建对象

public static void main(String[] args) throws Exception{
	Class c = Student.class;
	//这里会默认调用无参构造器来创建对象
	Object obj = c.newInstance();
	System.out.println(obj);
}

反射调用类中有参构造器创建对象

public static void main(String[] args) throws Exception{
	Class c = Student.class;
	//获取类中的带参构造器
	Constructor constructor = c.getConstructor(String.class, int.class);
	//调用有参构造器来创建对象，传入对应的参数值
	Object obj = constructor.newInstance("ton",20);
	System.out.println(obj);
}
持久的棒棒君
关注
专栏目录
史上最全的Unity面试题（含答案）
崔小妹儿Jessica的博客
12-13 3万+
一：什么是协同程序？ 在主线程运行的同时开启另一段逻辑处理，来协助当前程序的执行，协程很像多线程，但是不是多线程，Unity的协程实在每帧结束之后去检测yield的条件是否满足。 二：Unity3d中的碰撞器和触发器的区别？ 碰撞器是触发器的载体，而触发器只是碰撞器身上的一个属性。当Is Trigger=false时，碰撞器根据物理引擎引发碰撞，产生碰撞的效果，可以调用OnCol
Java：注解和反射
希望有点用
05-21 2530
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java基础：反射
weixin_45873793的博客
07-22 1069
反射就是在 Java 程序运行的过程中，动态获得某个类的方法变量，并调用的技术。反射的缺点主要有两个。如图是类的正常加载过程：反射的原理在于class对象。cr.
Java基础篇：反射机制详解
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
java 反射创建类_Java基础：反射机制详解
weixin_29599033的博客
02-21 1357
一、什么是反射：(1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取t对象的各种信息。(2)Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态...
Java基础之—反射（非常重要）
bhegi_seg的博客
04-03 1299
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象. 以上的总结
Java反射技术详解
热门推荐
黄林晴
04-14 24万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java基础系列：反射修改对象属性
天然玩家的博客
11-26 5478
1 应用场景 利用反射，通过类属性名称，修改类属性的值。 2 修改类属性值 2.1 实体类 package com.company.designpattern.reflect; import java.util.Objects; /** * 测试类，用于反射测试 * @author xindaqi * @since 2020-11-26 */ public class User { private String name; private String address;
Java反射：框架设计的灵魂
write less , do more
04-30 4804
框架：半成品软件。可以在框架的基础上进行软件开发，简化编码。 反射就是把Java类中的各个成员映射成一个个的Java对象。 即在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能调用它的任意一个方法和属性。 这种动态获取信息及动态调用对象方法的功能叫Java的反射机制。 好处： 1. 可以在程序运行过程中，操作这些对象。 1. 可以解耦，提高程序的可扩展性。
Java 基础进阶篇（十七）：反射概述及获取对象的方式
秀岩的博客
06-21 4012
一、反射概述 二、反射获取类对象 三、反射获取构造器对象 四、反射获取成员变量对象 五、反射获取方法对象 六、 反射的作用 6.1 绕过编译阶段为集合添加数据 6.2 通用框架的底层原理
java基础之反射讲解
04-10
### Java基础之反射讲解 #### 一、反射概念与应用场景 **反射**是Java语言提供的一种能在运行时分析和操作类及其成员的强大功能。通过反射，我们可以在程序运行期间动态地获取类的信息，并且能够创建和操作这些类...
javabasic:java基础
05-15
"javabasic:java基础"这一主题涵盖了Java语言的基础概念和关键知识点。 1. **基本语法**: Java的基础语法包括变量声明、数据类型（如整型、浮点型、字符型、布尔型）、运算符（算术、比较、逻辑、位运算等）、流程...
java-reflex-demo:java反射基础
05-17
在Java-reflex-demo中，我们将探讨这个主题的基础知识，通过实践代码来理解其工作原理。 首先，让我们了解什么是反射。在Java中，反射机制允许我们获取关于类的信息，包括类名、包名、父类、接口、构造器、方法和...
java基础编程必须知道的：SPI、反射、位运算
08-09
Java基础编程涵盖了许多核心概念，其中包括SPI（Service Provider Interface）、反射和位运算。这些特性都是Java强大灵活性的关键组成部分。 SPI（Service Provider Interface）是Java的一种服务发现机制，它允许...
java进阶技术：泛型、反射、注解
06-10
JAVA反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对以后学习框架有很大的帮助。注解（Annotation）是JDK1.5及以后引入的新特性，与类、接口、枚举是在同一个层次。可声明在包、类、字段、方法、局部...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 594
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1329
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 811
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 192
默认对常规Session的理解和使用，如何使用Set-Cookie。
Java基础：深入理解注解与反射机制
"深入理解Java注解与反射机制" 在Java编程中，注解（Annotation）和反射（Reflection）是两种非常重要的高级特性，它们分别提供了元数据和运行时的类信息访问能力。下面将详细解释这两个概念以及它们的应用。 ### ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值