Java反射实战
一、背景
最近的项目中需要使用到Java 反射的知识，以前不怎么了解，也基本没怎么用过，抽出一片时间，来具体学习和实战下Java的反射！拿来和大家分享以及记录方便以后学习！
二、反射相关概念解析
1.Class类
Class类：Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。
如何得到各个类的字节码即Class类呢？
[1].类名.class:直接通过类.class获得。
[2].对象.getClass()：通过对象调用其getClass方法获得。
[3].Class.forName("类全路径"):通过类加载器加载获得
注：Java中的原始基本类型：boolean, byte, char, short, int, long, float,double和关键词 void同样都有Class类，通过.class可获得它们的类字节码。
2.反射的概念
反射就是把Java类中的各种成分映射成相应的Java类，例如一个Java类中用一个Class类的对象表示一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，例如人是一个类，那么人的大脑、双手等也是一个个类。表示Java的Class类显然要提供一系列的方法，来获得其中的变量、方法、构造方法，修饰符、包等信息，这些信息就是用相应的类的实例对象来表示，他们是Field、Method、Contructor、Package等等。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示。
三、反射实战
测试Bean：Person.java
package com.hafiz.zhang.Bean;
public class Person {
public Integer id;
private String name;
public Person() {
}
public Person(Integer id, String name) {
super();
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person [id=" + id + ", name=" + name + "]";
}
public void sayHello() throws Exception{
System.out.println("Hello Reflect!");
}
}
1.使用反射获取对象所属类的全路径（包括报名和类名）
package com.hafiz.zhang.test; import com.hafiz.zhang.Bean.Person; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午4:28:35
* @Description 测试通过一个对象获取该对象所属于的类的全路径（包括完整包名和类名）
*/
public class ReflectTest1 {
public static void main(String[] args) {
Person person = new Person();
System.out.println("ClassName = " + person.getClass().getName());
}
}
测试结果：
ClassName = com.hafiz.zhang.Bean.Person
2.测试使用反射实例化Class类对象
package com.hafiz.zhang.test; import com.hafiz.zhang.Bean.Person; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午4:31:36
* @Description 测试获取Class类的三种方式
*/
public class ReflectTest2 {
public static void main(String[] args) {
Class<?> obj1 = null;
Class<?> obj2 = null;
Class<?> obj3 = null;
try {
//一般尽量要采用这种方式进行实例化Class类对象
obj1 = (Class<?>) Class.forName("com.hafiz.zhang.Bean.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
obj2 = new Person().getClass();
obj3 = Person.class; System.out.println("ClassName:" + obj1.getName());
System.out.println("ClassName:" + obj2.getName());
System.out.println("ClassName:" + obj3.getName());
}
}
测试结果：
ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person
ClassName:com.hafiz.zhang.Bean.Person
3.测试通过Class类对象实例化其他类
package com.hafiz.zhang.test; import com.hafiz.zhang.Bean.Person; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午4:38:15
* @Description 测试通过Class类对象实例化其他类
*/
public class ReflectTest3 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person person = null;
try {
person = (Person) clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if(null != person) {
person.setId(1);
person.setName("Hafiz.Zhang");
System.out.println("person=" + person);
}else{
System.out.println("实例化对象失败");
}
}
}
测试结果：
person=Person [id=1, name=Hafiz.Zhang]
4.测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）
package com.hafiz.zhang.test; import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException; import com.hafiz.zhang.Bean.Person; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午4:42:08
* @Description 测试通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）
*/
public class ReflectTest4 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p1 = null;
Person p2 = null;
Constructor<?>[] cs = clazz.getConstructors();
try {
p1 = (Person) cs[0].newInstance();//通过无参构造获得对象
p2 = (Person) cs[1].newInstance(1, "Hafiz.Zhang");//通过有参构造获得对象
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
System.out.println("Person1=" + p1);
System.out.println("Person2=" + p2);
}
}
测试结果：
Person1=Person [id=null, name=null]
Person2=Person [id=1, name=Hafiz.Zhang]
5.测试使用反射获取一个类实现的接口
接口Animal.java
package com.hafiz.zhang.Bean; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午6:13:37
* @Description 动物接口
*/
public interface Animal {
public abstract void eat();
public abstract void sleep();
}
接口Skill.java
package com.hafiz.zhang.Bean; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午6:14:06
* @Description 技能接口
*/
public interface Skill {
public abstract void sayMiao();
}
实现类：Cat.java
package com.hafiz.zhang.Bean;
public class Cat implements Animal, Skill {
private Integer num;
private String desc;
public Integer getNum() {
return num;
}
public void setNum(Integer num) {
this.num = num;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
@Override
public void eat() {
System.out.println("cat eat fish");
}
@Override
public void sleep() {
System.out.println("cat sleep in the day");
}
@Override
public void sayMiao() {
System.out.println("cat say miao");
}
public void sayHello(String name){
System.out.println("Hello " + name);
}
}
测试类
package com.hafiz.zhang.test; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午4:51:29
* @Description 测试使用反射获取一个类实现的接口
*/
public class ReflectTest5 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("Cat实现的接口有");
for(Class<?> cl : interfaces) {
System.out.println(cl.getName());
}
}
}
测试结果：
Cat实现的接口有
com.hafiz.zhang.Bean.Animal
com.hafiz.zhang.Bean.Skill
6.测试通过反射取得指定类的父类
package com.hafiz.zhang.test; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午5:03:25
* @Description 测试通过反射取得指定类的父类
*/
public class ReflectTest6 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?> superClass = clazz.getSuperclass();
System.out.println("SuperClass=" + superClass);
}
}
测试结果：SuperClass=class com.hafiz.zhang.Bean.Person
7.测试通过反射获得其他类中的全部构造函数
package com.hafiz.zhang.test; import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午5:06:02
* @Description 测试通过反射获得其他类中的全部构造函数
*/
public class ReflectTest7 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?>[] cs = clazz.getConstructors();
//实现方式1
/*for(Constructor<?> item : cs) {
System.out.println("构造方法:" + item.getName());
}*/
//实现方式2
for(Constructor<?> item : cs) {
System.out.print("构造方法:");
System.out.print(Modifier.toString(item.getModifiers()) + " ");
System.out.print(item.getName() + "(");
Class<?>[] paramterTypes = item.getParameterTypes();
for(int i = 0; i < paramterTypes.length; i++) {
System.out.print(paramterTypes[i].getName() + " arg" + i);
if(i < paramterTypes.length-1) {
System.out.print(",");
}
}
System.out.println(")");
}
}
}
测试结果：
构造方法:public com.hafiz.zhang.Bean.Person()
构造方法:public com.hafiz.zhang.Bean.Person(java.lang.Integer arg0,java.lang.String arg1)
8. 测试通过反射获取类中的所有方法（包括方法包含的异常）
package com.hafiz.zhang.test; import java.lang.reflect.Method;
import java.lang.reflect.Modifier; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午5:22:51
* @Description 测试通过反射获取类中的所有方法
*/
public class ReflectTest8 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Person");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Method[] methods = clazz.getDeclaredMethods();
for(Method method : methods) {
Class<?> returnType = method.getReturnType();
System.out.print(Modifier.toString(method.getModifiers()) + " ");
System.out.print(returnType.getName() + " " + method.getName() + "(");
Class<?>[] paras = method.getParameterTypes();
for(int i = 0 ; i < paras.length ; i++) {
System.out.print(paras[i].getName() + " arg" + i);
if(i < paras.length - 1) {
System.out.print(",");
}
}
Class<?>[] exces = method.getExceptionTypes();
if(exces.length > 0) {
System.out.print(") throws ");
for(int j = 0; j < exces.length; j++) {
System.out.print(exces[j].getName());
if(j < exces.length - 1) {
System.out.print(", ");
}
}
}else{
System.out.print(")");
}
System.out.println();
}
}
}
测试结果：
public java.lang.String toString()
public java.lang.String getName()
public void setName(java.lang.String arg0)
public java.lang.Integer getId()
public void sayHello() throws java.lang.Exception
public void setId(java.lang.Integer arg0)
9.测试通过反射获取类中所有的属性
package com.hafiz.zhang.test; import java.lang.reflect.Field;
import java.lang.reflect.Modifier; /**
* @author hafiz.Zhang
* @Date 2016年5月18日 下午5:38:09
* @Description 测试通过反射获取类中所有的属性
*/
public class ReflectTest9 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Field[] fields = clazz.getDeclaredFields();
System.out.println("=========通过反射获取指定类中所有的属性=========");
for(Field field : fields) {
System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getType().getName() + " " + field.getName());
}
System.out.println("=========通过反射获取指定类实现的接口或者父类中所有的属性=========");
Field[] fields2 = clazz.getSuperclass().getDeclaredFields();
for(Field item : fields2) {
System.out.println(Modifier.toString(item.getModifiers()) + " " + item.getType() + " " + item.getName());
}
}
}
测试结果：
=========通过反射获取指定类中所有的属性=========
private java.lang.Integer num
private java.lang.String desc
=========通过反射获取指定类实现的接口或者父类中所有的属性=========
public class java.lang.Integer id
private class java.lang.String name
10.测试使用反射调用指定类的方法
package com.hafiz.zhang.test; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午3:22:33
* @Description 测试使用反射调用指定类的方法
*/
public class ReflectTest10 {
public static void main(String[] args) {
Class<?> clazz = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
try {
//调用Cat类中的eat无参方法
Method method = clazz.getMethod("eat");
method.invoke(clazz.newInstance());
//调用Cat类中的sayHello有参方法
Method method2 = clazz.getDeclaredMethod("sayHello", String.class);
method2.invoke(clazz.newInstance(), "Hafiz.Zhang");
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
测试结果：
cat eat fish
Hello Hafiz.Zhang
11.测试通过反射调用其他类中的setter和getter方法
package com.hafiz.zhang.test; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午3:29:34
* @Description 测试通过反射调用其他类中的setter和getter方法
*/
public class ReflectTest11 {
public static void main(String[] args) {
Class<?> clazz = null;
Object obj = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
obj = clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
getter(obj,"Desc");
setter(obj,"Desc","测试调用set方法",String.class);
getter(obj,"Desc");
} private static void getter(Object obj, String name) {
try {
Method method = obj.getClass().getMethod("get"+name);
System.out.println(name + ":" + method.invoke(obj));
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} private static void setter(Object obj, String name, String desc, Class<?> type) {
try {
Method method = obj.getClass().getMethod("set" + name, type);
method.invoke(obj, desc);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
测试结果：
Desc:null
Desc:测试调用set方法
12.测试通过反射操作属性
package com.hafiz.zhang.test; import java.lang.reflect.Field; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午3:41:59
* @Description 测试通过反射操作属性
*/
public class ReflectTest12 {
public static void main(String[] args) {
Class<?> clazz = null;
Object obj = null;
try {
clazz = Class.forName("com.hafiz.zhang.Bean.Cat");
obj = clazz.newInstance();
Field field = clazz.getDeclaredField("desc");
//若要设置private属性，需要设置
field.setAccessible(true);//设置成员变量可访问，包括private成员变量（暴力反射）,private成员通过这步操作才能被访问
field.set(obj, "this is test demo");
System.out.println("Desc=" + field.get(obj));
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} }
}
测试结果：Desc=this is test demo
13.测试通过反射进行数组操作
package com.hafiz.zhang.test; import java.lang.reflect.Array; /**
* @author hafiz.Zhang
* @Date 2016年5月19日 下午4:52:21
* @Description 测试通过反射进行数组操作
*
*/
public class ReflectTest13 {
public static void main(String[] args) {
Integer[] array = {1,2,3,4,5,6};
Class<?> clazz = array.getClass().getComponentType();
System.out.println("数组类型：" + clazz.getName());
System.out.println("数组长度：" + Array.getLength(array));
System.out.println("数组第一个元素：" + Array.get(array, 0));
Array.set(array, 0, 8);
System.out.println("修改之后数组第一个元素：" + Array.get(array, 0));
System.out.println("=============反射修改数组长度=================");
Integer[] arr2 = (Integer[])changeLength(array, 10);
print(arr2);
}
private static void print(Object obj) {
Class<?> clazz = obj.getClass();
if(!clazz.isArray()) {
return;
}
System.out.println("数组长度为：" + Array.getLength(obj));
for(int i = 0; i < Array.getLength(obj); i++){
System.out.print(Array.get(obj, i) + " ");
}
}
public static Object changeLength(Object obj, Integer length){
Class<?> clazz = obj.getClass().getComponentType();
Object newArr = Array.newInstance(clazz, length);
Integer len = Array.getLength(obj);
System.arraycopy(obj, 0, newArr, 0, len);
return newArr;
}
}
测试结果：
数组类型：java.lang.Integer
数组长度：6
数组第一个元素：1
修改之后数组第一个元素：8
=============反射修改数组长度=================
数组长度为：10
8 2 3 4 5 6 null null null null
Java反射实战的更多相关文章
- java反射机制简单实例
目录 Java反射 简单实例 @(目录) Java反射 Java语言允许通过程序化的方式间接对Class进行操作.Class文件由类装载器装载后,在JVM中将形成一份描述Class结构的元信息对象,通 ...
- 浅谈Java反射
什么是反射? JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意方法和属性:这种动态获取信息以及动态调用对象方法的功能称为java语 ...
- Java反射机制小结和实际操作
一.什么是反射 1.编译和运行 在了解什么是Java反射机制前,先聊聊Java的编译和运行. 还记得第一次使用记事本编写第一个Java程序的场景吗?通过命令窗口,使用javac命令编译一个.java文 ...
- 文末送书四本 | 这篇Java反射机制太经典！不看后悔！
先看再点赞,给自己一点思考的时间,如果对自己有帮助,微信搜索[程序职场]关注这个执着的职场程序员. 价值:Java技能,面试经验指导,简历优化,职场规划指导,技能提升方法,讲不完的职场故事,个人成长经 ...
- 第28章 java反射机制
java反射机制 1.类加载机制 1.1.jvm和类 运行Java程序:java 带有main方法的类名 之后java会启动jvm,并加载字节码(字节码就是一个类在内存空间的状态) 当调用java命令 ...
- Java反射机制
Java反射机制 一:什么事反射机制 简单地说,就是程序运行时能够通过反射的到类的所有信息,只需要获得类名,方法名,属性名. 二:为什么要用反射: 静态编译:在编译时确定类型,绑定对象,即通过 ...
- java反射(基础了解)
package cn.itcast_01; /** *Person类 */ public class Person { /** 姓名 */ private String name; ...
- java基础知识（十一）java反射机制（上）
java.lang.Class类详解 java Class类详解 一.class类 Class类是java语言定义的特定类的实现,在java中每个类都有一个相应的Class对象,以便java程序运行时 ...
- java基础知识（十一）java反射机制（下）
1.什么是反射机制? java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法,对于任意一个对象都能够调用他的属性和方法,这种动态获取属性和方法的功能称为java的反射机制. ...
随机推荐
- OC第五节 ——点语法和@property
一.setter和getter函数 1.回忆:如何访问对象中的成员变量 2.setter和getter函数的作用 setter 方法: 修改对象的字段/实例变 ...
- mysql python image 图像存储读取
最近做一些数据库调研的工作,目标是实现影像更快的入库.出库.查询,并实现并行访问等操作. 将结果总结成一个mysqlImg类. 关于mongodb的图像存储,参见http://www.cnblogs. ...
- jQuery Colorbox插件
http://www.open-open.com/lib/view/open1338084606042.html jQuery Colorbox是一款非常好的内容播放插件.它集弹出层.幻灯片播放功能于 ...
- DOM之节点层次
1.1 Node类型 DOM1级定义了一个Node接口,该接口将由DOM中的所有节点类型实现.这个Node接口在JS中是作为Node类型实现的:除了IE之外,其他浏览器可访问这个类型.JS中的所有节点 ...
- UOJ25——IOI2014Wall
1.题目大意:这道题也是线段树修改,有两种修改,一个区间中大于h都变成h,一个区间中小于h都变成h,单点询问 主要是这几种操作 2.分析:这道题是双标记,还是父亲的优先级比儿子低,自己用手推推就可以知 ...
- SNMP进阶
管理信息库:MIB 我们要扩展mib首先必须清楚mib是如何定义的,用的什么语言,有哪些约定,遵循哪些规则等等.这些基本东西掌握过后,我们就可以很轻松的来写自己的mib文件了. 所谓管理信息库,或者M ...
- Android学习之路书籍推荐
Android开发书籍推荐:从入门到精通系列学习路线书籍介绍 JAVA入门书籍: < Introduction to java programming > < Core java & ...
- qt-4.8.5 显示图片居中笔记
已经太久没有写过qt的程序了,所以导致的后果就是一个很简单的程序写了老半天还没写完整. 今天想实现的功能在原来软件的基础上显示他的版本. 因为想在该界面显示一个logo,一开始在pc机上跑发现图片一直 ...
- BZOJ 3111: [Zjoi2013]蚂蚁寻路
Sol DP. 首先观察转折,画画图,看看移动路线,可以非常轻易的发现如果走到起点的下方是回不去的.. 然后它就相当于一个底部是平的,顶部凹凹凸凸的形状,每右转两次或左转两次就会形成小矩阵,这样就可以 ...
- java.lang.NoClassDefFoundError: [Lorg/hibernate/engine/FilterDefinition
解决办法: 原先:<bean id="sessionFactory"class="org.springframework.orm.hibernate3.annota ...