Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
下面介绍下java反射机制的使用
package cn.csdn.reflect;
import java.awt.Button;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.LinkedList;
public class ReflectClass {
//参考地址 http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html
public void geteClassBegin(){
Demo demo = new Demo();
System.out.println(demo.getClass().getSuperclass());
String str = "23432";;
System.out.println(str.getClass()); // getClass java.lang.String class .getSuperclass() java.lang.Object
Button b = new Button();
System.out.println(b.getClass().getSuperclass().getSuperclass());
System.out.println(Boolean.TYPE);
LinkedList linkedList = new LinkedList();
System.out.println(linkedList.getClass().getSuperclass().getSuperclass().getSuperclass().getSuperclass());
}
//3种不同的方法获取类名
public void getClassMethod(){
try {
//鉴于使用这种方式
Class<?> demo = Class.forName("cn.csdn.reflect.Demo");
System.out.println(demo.getName());
Class<?> demo1 = Demo.class;
System.out.println(demo1.getName());
Class<?> demo2 = new Demo().getClass();
System.out.println(demo2.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//通过无参构造实例化对象 -- Demo
public void getNewClass(){
try {
Class<?> clas = Class.forName("cn.csdn.reflect.Demo");
Demo demo = (Demo)clas.newInstance();
demo.setAddress("黑悲伤");
demo.setEmail("sdfdsf@qq.com");
System.out.println(demo.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
//获取类中所有的构造函数 --Demo1
public void getConstructor() throws Exception{
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
Constructor<?> cons[] = clas.getConstructors();
for(Constructor<?> con:cons){
System.out.println(con);
}
}
//class 获取一个类的全部框架 ---- Demo1的属性 本类属性的获取和父类的所有public的获取
public void getClassAll() throws Exception{
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
//获取Demo1的全部属性及类型
// getDeclaredFields 获取这个类的所有属性字段 包括 private public proteced
Field[] fields = clas.getDeclaredFields();
for(Field field:fields){
//System.out.println(field);
int modifier = field.getModifiers();
String str = Modifier.toString(modifier);
//输出值如： private java.lang.Integer id
System.out.println(str+"========="+field.getType().getName()+"======"+field.getName());
}
//getFields 获取 本类及父类的所有public的方法 只有public的方法
Field[] fields1 = clas.getFields();
for(Field field:fields1){
System.out.println(field);
int mo = field.getModifiers();
String str = Modifier.toString(mo);
System.out.println(str+" "+field.getType().getName()+" "+field.getName());
}
}
//通过反射调用其他类中的方法
public void getMethod() throws Exception{
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
//调用Demo1类中的方法 hello
Method method = clas.getMethod("hello");
//对方法进行实例化
method.invoke(clas.newInstance());
}
//调用get set 方法
public void getSetMethod() throws Exception{
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
Object obj = clas.newInstance();
Method method = clas.getMethod("getId");
System.out.println(method.invoke(obj));
}
//通过反射操作属性 给属性设置值 如果此属性是私有的，则必须加上setAccessible 如果为共有的 则不用考虑
public void getOperateAttribute() throws Exception{
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
Object obj = clas.newInstance();
Field field = clas.getDeclaredField("name");
//此属性为私有变量的时候必须要做此操作 才可以通过访问，否则会报错 java.lang.IllegalAccessException: Class cn.csdn.reflect.ReflectClass can not access a member of class cn.csdn.reflect.Demo1 with modifiers "private"
field.setAccessible(true);
field.set(obj,"张三");
System.out.println(field.get(obj));
//输出结果：张三
}
//通过反射类中的Array可以得到数据的信息并可以修改数组的大小
public void getArrayAttribute() throws Exception{
int[] array = {1,2,3,4,5};
Class<?> demo = array.getClass().getComponentType();
System.out.println("数组的类型："+demo.getName()+"====数组的长度："+Array.getLength(array)+"=获取数组的第一个元素="+Array.get(array, 0));
Array.set(array,0,100);
System.out.println(Array.get(array, 0));
//输出结果：
//数组的类型：int====数组的长度：5=获取数组的第一个元素=1
//100
}
//修改数组的大小 Array.newInstance()方法
public void getArrayLength() throws Exception{
int[] array={1,2,3,4,5,6,7,8,9};
//修改数组大小之前的循环输出
for(int i = 0;i<Array.getLength(array);i++){
if(i==(Array.getLength(array)-1)){
System.out.println();
}else{
System.out.print(Array.get(array, i)+" ");
}
}
// 输出 1 2 3 4 5 6 7 8
Class<?> demo = array.getClass().getComponentType();
Object arrayNew = Array.newInstance(demo, 15);
int length = Array.getLength(array);
//System.arraycopy()实现数组之间的复制
//arraycopy(Object src, int srcPos, Object dest, int destPos, int length) src:源数组 srcPos：源数字开始复制的位置
//dest 目的数组 (arrayNew) destPos：目的数组存在的起始位置 length是复制的长度
System.arraycopy(array, 0, arrayNew, 0, length);
System.out.println("修改之后的长度为==="+Array.getLength(arrayNew));//15
for(int i = 0;i<Array.getLength(arrayNew);i++){
System.out.print(Array.get(arrayNew, i)+" ");
}
//1 2 3 4 5 6 7 8 9 0 0 0 0 0 0
}
//通过反射得到实体类对应的值
public void getValue() throws Exception{
//getFields 获取 本类及父类的所有public的方法 只有public的方法
// field.get()可以得到对应的实体类中的值
Class<?> clas = Class.forName("cn.csdn.reflect.Demo1");
Demo1 demo = (Demo1) clas.newInstance();
demo.setAddress("2332");
demo.setEmail("342");
Field[] fields1 = clas.getFields();
for(Field field:fields1){
int mo = field.getModifiers();
String str = Modifier.toString(mo);
System.out.println(str+" "+field.getType().getName()+" "+field.getName()+"=="+field.get(demo));
}
//输出结果:
/*
* public java.lang.String phone==null
public java.lang.String address==2332
public java.lang.String email==342
*/
}
public void getCase() throws Exception{
//实例介绍 当想要同时获取一个对象在修改前和修改后的值的时候，可用到反射
Demo before = null; //获取修改前的对象
Demo1 vo = null;//获取修改之后的对象
Class beforeClazz = before.getClass();
Method[] beforeMethods = beforeClazz.getMethods();
for (Method method : beforeMethods) {
//通过之前的对象获取对应的值
Object beforeValue = method.invoke(before);
//获取修改之后的值
Object afterValue = method.invoke(vo);
}
}
}
原文地址：http://blog.csdn.net/hanxiaoshuang123/article/details/37877231
