Java反射Reflect的使用详解
一. 什么是反射
在运行状态中,对于任意一个类,都能够知道其所有属性和方法,对于任意一个对象,都能够调用其任意方法和属性,这种动态获取信息、动态调用方法的能力称为Java语言的反射机制,大部分框架都有用到反射机制,了解反射的使用方法非常重要。
一个类通常包含了属性、方法、构造函数等,而Java一般情况下是现有类再有对象,通过对象调用各种属性和方法,而Java反射则是通过已有的对象,反过来得到其所属类的相关信息,调用所属类的相关方法。
二. 反射的基础Class
2.1 Class类概述
我们知道在Java的世界中,万事万物皆对象。其实类本身也是对象,任何一个类都是Class类的实例对象。
//定义了一个SuperHero的类
public class SuperHero {}
如上面定义的SuperHero类,是类也是对象,
对象:SuperHero类是Class类的实例,Class类是SuperHero的类类型,故而为对象;
类:以类的方式创建,SuperHero本身可以调用SuperHero ironMan = new SuperHero ()
被实例化,ironMan 就是创建的实体,故而也是类。
Class类很特殊,它表示了某个类的类类型,被不可被继承,每个类的Class对象仅有一个,Class类没有公共构造函数。 相反, Class对象由Java虚拟机自动构建,因为加载了类,并且通过调用类加载器中的defineClass
方法,原始Java类型( boolean
, byte
, char
, short
, int
, long
, float
和double
),和关键字void
也表示为Class对象
//Class源码,final修饰不可被继承,构造函数是private的,不可手动实例化
public final class Class<T> {
private Class(ClassLoader loader) {
// Initialize final field for classLoader. The initialization value of non-null
// prevents future JIT optimizations from assuming this final field is null.
classLoader = loader;
}
}
public static void main(String[] args) {
try {
Class clazz1 = Class.forName("java.lang.Integer");
Class clazz2 = Class.forName("java.lang.Integer");
System.out.println(clazz1 == clazz2);
System.out.println(int.class);
System.out.println(void.class);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
运行结果为:
true
int
void
2.2 Class类对象获取的三种方式
先定义一个类
package reflectdemo;
import java.io.Serializable;
/**
* 超级英雄类
*/
public class SuperHero implements Serializable {
public static final String ADDRESS = "earth";
private String id;
private String name;
private Integer age;
private String skill;
public SuperHero() {
}
public SuperHero(String id, String name, Integer age, String skill) {
this.id = id;
this.name = name;
this.age = age;
this.skill = skill;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
public void print(){
System.out.println("超级英雄:" + this.name);
}
}
2.2.1 通过对象获取Class
public static void main(String[] args) {
SuperHero ironMan = new SuperHero("1","钢铁侠",35, "战甲");
Class clazz = ironMan.getClass();
System.out.println(clazz.getName());
}
输出结果:
reflectdemo.SuperHero
2.2.2 通过类获取Class
public static void main(String[] args) {
Class clazz = SuperHero.getClass();
System.out.println(clazz.getName());
}
输出结果:
reflectdemo.SuperHero
2.2.3 传入类路径获取Class
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
System.out.println(clazz.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
输出结果:
reflectdemo.SuperHero
三种创建方式:
第一种方式对象已经有了,所有的操作直接通过该对象进行即可,
第二种方式需要import将类引入,也不是常用的方式,
第三种仅需传入类的路径,即可得到类的相关信息,是最常用的方式。
2.2.4 获取类信息的常用方法
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//获取类名称(含路径)
System.out.println(clazz.getName());
//获取类名称(不含路径)
System.out.println(clazz.getSimpleName());
//获取所在包
System.out.println(clazz.getPackage());
//通过Class创建对象
SuperHero hero = (SuperHero)clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
输出结果:
reflectdemo.SuperHero
SuperHero
package reflectdemo
这里提前说明一下:Class中两个功能相同的方法,若其中一个带有Declared字样,表示针对类中所有声明的变量、方法、构造函数等,而对应不带Declared字样的方法,则表示仅对公有(public)成员变量、方法起作用,下面不再重复描述,下面仅对带有Declared字样的方法进行讲解。
三. 反射-构造函数
3.1 getDeclaredConstructor(Class<?>...parameterTypes)
public class ClassUtils {
/**
* 获取构造函数
* @param clazz 类
* @param params 构造函数参数类型
* @throws NoSuchMethodException
*/
public static void getDeclaredConstructor(Class clazz, Class[] params) throws NoSuchMethodException {
System.out.println(clazz.getDeclaredConstructor(params));
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//打印无参构造函数
ClassUtils.getDeclaredConstructor(clazz, null);
//打印有参构造函数
ClassUtils.getDeclaredConstructor(clazz, new Class[]{String.class, String.class, Integer.class, String.class});
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
public reflectdemo.SuperHero()
public reflectdemo.SuperHero(java.lang.String,java.lang.String,java.lang.Integer,java.lang.String)
3.2 getDeclaredConstructors()
public class ClassUtils {
/**
* 遍历构造函数
* @param clazz 类
*/
public static void getDeclaredConstructors(Class clazz){
//获取所有的构造函数
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
//直接打印构造函数
System.out.println(constructor);
//打印构造函数名称
System.out.println(constructor.getName());
//打印构造函数参数
Parameter[] parameters = constructor.getParameters();
for(Parameter parameter : parameters){
System.out.print(parameter);
System.out.print(", ");
}
System.out.println("---------------------");
}
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//遍历构造函数
ClassUtils.getDeclaredConstructors(clazz);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
public reflectdemo.SuperHero()
reflectdemo.SuperHero
---------------------
public reflectdemo.SuperHero(java.lang.String,java.lang.String,java.lang.Integer,java.lang.String)
reflectdemo.SuperHero
java.lang.String arg0, java.lang.String arg1, java.lang.Integer arg2, java.lang.String arg3, ---------------------
四. 反射-成员变量
4.1 getDeclaredField(String name)
public class ClassUtils {
/**
* 获取属性字段
* @param clazz 类
* @param fieldName 属性名称
* @throws Exception
*/
public static void getDeclaredField(Class clazz, String fieldName) throws Exception{
System.out.println(clazz.getDeclaredField(fieldName));
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//测试公有属性
ClassUtils.getDeclaredField(clazz, "ADDRESS");
//测试私有属性
ClassUtils.getDeclaredField(clazz, "name");
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
public static final java.lang.String reflectdemo.SuperHero.ADDRESS
private java.lang.String reflectdemo.SuperHero.name
4.3 getDeclaredFields()
public class ClassUtils {
/**
* 遍历clazz对象已有的成员变量
* @param clazz
*/
public static void getDeclaredFields(Class clazz){
Field[] fields = clazz.getDeclaredFields();
for (Field field: fields) {
//如果要设置值,需要加入下面这句,反射对象在使用时不使用Java语言访问检查
//field.setAccessible(true);
//直接打印Field
System.out.println(field);
//手动获取变量类型和变量名称
System.out.println(field.getType().getName() + " " +field.getName());
System.out.println("--------------------");
}
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//遍历成员变量
ClassUtils.getDeclaredFields(clazz);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
public static final java.lang.String reflectdemo.SuperHero.ADDRESS
java.lang.String ADDRESS
--------------------
private java.lang.String reflectdemo.SuperHero.id
java.lang.String id
--------------------
private java.lang.String reflectdemo.SuperHero.name
java.lang.String name
--------------------
private java.lang.Integer reflectdemo.SuperHero.age
java.lang.Integer age
--------------------
private java.lang.String reflectdemo.SuperHero.skill
java.lang.String skill
--------------------
五. 反射-成员方法
5.1 getDeclaredMethod(String name, Class<?>... parameterTypes)
public class ClassUtils {
/**
* 获取成员方法
* @param clazz 类
* @param methodName 方法名称
* @param params 参数列表
* @throws Exception
*/
public static void getDeclaredMethod(Class clazz, String methodName, Class[] params) throws Exception{
Method method = clazz.getDeclaredMethod(methodName, params);
System.out.println("直接打印");
System.out.println(method);
System.out.println("手动构建");
//获取返回类型
System.out.print(method.getReturnType().getSimpleName() + " ");
//获取方法名称
System.out.print(method.getName() + "(");
//获取参数类型
Class[] paramTypes = method.getParameterTypes();
for(int i = 0; i < paramTypes.length; i++){
Class param = paramTypes[i];
if(i < paramTypes.length - 1){
System.out.print(param.getSimpleName() + ", ");
}else {
System.out.print(param.getSimpleName());
}
}
System.out.print(")");
System.out.println();
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//打印无参数方法
ClassUtils.getDeclaredMethod(clazz, "getName", null);
//打印有参数方法
ClassUtils.getDeclaredMethod(clazz, "setName", new Class[]{String.class});
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
直接打印
public java.lang.String reflectdemo.SuperHero.getName()
手动构建
String getName()
直接打印
public void reflectdemo.SuperHero.setName(java.lang.String)
手动构建
void setName(String)
5.2 getDeclaredMethods()
public class ClassUtils {
/**
* 遍历方法
* @param clazz
*/
public static void getDeclaredMethods(Class clazz){
//获取类中所有声明的方法
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods){
System.out.println(method);
}
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//遍历方法
ClassUtils.getDeclaredMethods(clazz);
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
public java.lang.String reflectdemo.SuperHero.getName()
public java.lang.String reflectdemo.SuperHero.getId()
public void reflectdemo.SuperHero.setName(java.lang.String)
public void reflectdemo.SuperHero.print()
public java.lang.String reflectdemo.SuperHero.getSkill()
public void reflectdemo.SuperHero.setAge(java.lang.Integer)
public void reflectdemo.SuperHero.setSkill(java.lang.String)
public void reflectdemo.SuperHero.setId(java.lang.String)
public java.lang.Integer reflectdemo.SuperHero.getAge()
5.3 方法执行
public class ClassUtils {
/**
* 执行set方法(通过Method的invoke方法)
* @param o 待执行的实体
* @param methodName 方法名称
* @param params 方法参数类型
* @throws Exception
*/
public static void invokeSetMethod(Object o, String methodName, Class[] params) throws Exception {
Method method = o.getClass().getDeclaredMethod(methodName, params);
method.invoke(o, "钢铁侠");
}
/**
* 执行get方法(通过Method的invoke方法)
* @param o 待执行的实体
* @param methodName 方法名称
* @throws Exception
*/
public static void invokeGetMethod(Object o, String methodName) throws Exception{
Method method = o.getClass().getDeclaredMethod(methodName);
Object obj = method.invoke(o);
System.out.println(obj);
}
}
public class ClassTest {
public static void main(String[] args) {
try {
Class clazz = Class.forName("reflectdemo.SuperHero");
//创建实体
Object o = clazz.newInstance();
//调用set方法
ClassUtils.invokeSetMethod(o, "setName", new Class[]{String.class});
//调用get方法
ClassUtils.invokeGetMethod(o, "getName");
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果为:
钢铁侠
下面是对invoke方法的API说明
public Object invoke(Object obj, Object... args) throws IllegalAccessException,
IllegalArgumentException, InvocationTargetException
在具有指定参数的
方法
对象上调用此方法
对象表示的基础方法。如果底层方法是静态的,则指定的
obj
参数将被忽略。 它可能为null。如果底层方法所需的形式参数的数量为0,则提供的
args
数组的长度为0或为空。如果底层方法是一个实例方法,它将使用动态方法查找来调用,如“Java语言规范”第二版,第15.12.4.4节所述; 特别是将会发生基于目标对象的运行时类型的覆盖。
如果底层方法是静态的,则如果尚未初始化该方法,那么声明该方法的类将被初始化。
如果方法正常完成,则返回的值将返回给调用者; 如果值具有原始类型,则首先将其适当地包装在对象中。 但是,如果该值具有基本类型的数组的类型,则该数组的元素不会包含在对象中; 换句话说,返回一个原始类型的数组。 如果底层方法返回类型为void,则调用返回null。
参数
obj
- 从底层方法被调用的对象
args
- 用于方法调用的参数结果
由该对象表示的方法在
obj
上调用args
异常
IllegalAccessException
- 如果这个方法
对象正在强制执行Java语言访问控制,并且底层方法是无法访问的。
IllegalArgumentException
- 如果方法是一个实例方法,并且指定的对象参数不是声明底层方法(或其子类或实现者)的类或接口的实例; 如果实际和正式参数的数量不同; 如果原始参数的解包转换失败; 或者如果在可能的展开之后,通过方法调用转换,参数值不能转换为相应的形式参数类型。
InvocationTargetException
- 如果底层方法抛出异常。
NullPointerException
- 如果指定的对象为空,该方法为实例方法。
ExceptionInInitializerError
- 如果由此方法引发的初始化失败。
六. 总结
本文对反射的定义,反射使用过程中重要的、常用的类和方法进行了讲解,包括Class类,Constructor类,Field类,Method类的说明及使用。反射机制允许在运行时判断任意一个对象所属的类、构造任意一个类的对象、判断任意一个类所具有的成员变量和方法、调用任意一个对象的方法。大大提高了系统的灵活性和扩展性,不过凡事都有两面性,反射破坏了Java封装的特性,相对来说不安全,需要根据场景酌情考虑,若有不对之处,请批评指正,望共同进步,谢谢!
Java反射Reflect的使用详解的更多相关文章
- JAVA反射概念及使用详解(超详细)
JAVA反射概念及使用详解 一.什么是反射? 反射:框架设计的灵魂 框架:半成品软件.可以在框架的基础上进行软件开发,简化编码 反射:将类的各个组成部分封装为其他对象,这就是反射机制 好处: ...
- Java基础-反射(reflect)技术详解
Java基础-反射(reflect)技术详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.类加载器 1>.JVM 类加载机制 如下图所示,JVM类加载机制分为五个部分 ...
- Scala进阶之路-反射(reflect)技术详解
Scala进阶之路-反射(reflect)技术详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. Scala中的反射技术和Java反射用法类似,我这里就不一一介绍反射是啥了,如果对 ...
- Java中的main()方法详解
在Java中,main()方法是Java应用程序的入口方法,也就是说,程序在运行的时候,第一个执行的方法就是main()方法,这个方法和其他的方法有很大的不同,比如方法的名字必须是main,方法必须是 ...
- Java基础-面向接口编程-JDBC详解
Java基础-面向接口编程-JDBC详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.JDBC概念和数据库驱动程序 JDBC(Java Data Base Connectiv ...
- Java网络编程和NIO详解9:基于NIO的网络编程框架Netty
Java网络编程和NIO详解9:基于NIO的网络编程框架Netty 转自https://sylvanassun.github.io/2017/11/30/2017-11-30-netty_introd ...
- java中的io系统详解 - ilibaba的专栏 - 博客频道 - CSDN.NET
java中的io系统详解 - ilibaba的专栏 - 博客频道 - CSDN.NET 亲,“社区之星”已经一周岁了! 社区福利快来领取免费参加MDCC大会机会哦 Tag功能介绍—我们 ...
- Java开发利器Myeclipse全面详解
Java开发利器Myeclipse全面详解: Ctrl+1:修改代码错误 Alt+Shift+S:Source命令 Ctrl+7:单行注释 Ctrl+Shift+/ :多行注释 Ctrl+I :缩进( ...
- [译]Java Thread join示例与详解
Java Thread join示例与详解 Java Thread join方法用来暂停当前线程直到join操作上的线程结束.java中有三个重载的join方法: public final void ...
随机推荐
- Java编程思想:XML
/* 本次实验需要在www.xom.nu上下载XOM类库 */ import nu.xom.*; import java.io.BufferedOutputStream; import java.io ...
- [原创]MySQL数据库查询和LVM备份还原学习笔记记录
一.查询语句类型: 1)简单查询 2)多表查询 3)子查询 4)联合查询 1)简单查询: SELECT * FROM tb_name; SELECT field1,field2 FROM tb_nam ...
- Oracle粗心大意总结篇
有时候写sql语句不细心的话,很容易犯大错误,导致你纠结好久,找不到原因,慢慢总结: 错误1: SELECT * FROM( SELECT USER.*, ROWNUM AS CON FROM USE ...
- RabbitMQ(一):RabbitMQ快速入门
RabbitMQ是目前非常热门的一款消息中间件,不管是互联网大厂还是中小企业都在大量使用.作为一名合格的开发者,有必要对RabbitMQ有所了解,本文是RabbitMQ快速入门文章. RabbitMQ ...
- python 中_init_函数以及参数self
1)class类包含: 类的属性:类中所涉及的变量 类的方法:类中函数 2)_init_函数(方法) 1.首先说一下,带有两个下划线开头的函数是声明该属性为私有,不能在类地外部被使用或直接访问. 2. ...
- Linux/Ubuntu正确卸载LXDE
第一步: sudo apt-get remove lxde 第二步 sudo apt autoremove lxde
- c语言进阶4-有返回值函数
一. 从函数返回 从函数返回就是返回语句的第一个主要用途.在程序中,有两种方法可以终止函数的执行,并返回到调用函数的位置.第一种方法是在函数体中,从第一句一直执行到最后一句,当所有语句 ...
- C#3.0新增功能09 LINQ 基础06 LINQ 查询操作中的类型关系
连载目录 [已更新最新开发文章,点击查看详细] 若要有效编写查询,应了解完整的查询操作中的变量类型是如何全部彼此关联的. 如果了解这些关系,就能够更容易地理解文档中的 LINQ 示例和代码示例. ...
- [leetcode] 290. Word Pattern (easy)
原题 思路: 建立两个哈希表,分别保存: 1 模式 :单词 2 单词 :是否出现过 水题 /** * @param {string} pattern * @param {string} str * @ ...
- Django REST Framework(DRF)_第一篇
认识RESTful REST是设计风格而不是标准,简单来讲REST规定url是用来唯一定位资源,而http请求方式则用来区分用户行为. REST接口设计规范 HTTP常用动词 GET /books:列 ...