Java反射详解
01、反射是什么？
反射，就是通过生成的字节码来生成对象，扩展了程序的灵活性。具体，在java编程中首先需要编译生成字节码，即.class文件，JVM根据这些.class文件对对象进行管理，那么反射就是在这些文件基础上进行的操作。反射可以用来生成具体的对象、获得对象的某个属性值、执行对象的方法、获得类的静态属性、执行类的静态方法、有参、无参实例化等，反射进行的首要基础是生成运行时的Class对象，有三种方式，a Class runtimeClass=object.class b Class runtimeClass=Object.getClass() c Class runtimeClass=Class.forName("类所在的完整路径") ,生成了这个运行时的对象之后，就可以进行各种操作了。
反射类所在的包是 java.lang.reflect
02、反射怎么用？
Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1. 得到某个对象的属性
public Object getProperty(Object owner, String fieldName) throws Exception
{
<span style="white-space:pre"> </span>Class ownerClass = owner.getClass();
<span style="white-space:pre"> </span>Field field = ownerClass.getField(fieldName);
<span style="white-space:pre"> </span>Object property = field.get(owner);
<span style="white-space:pre"> </span>return property;
}
2. 得到某个类的静态属性
public Object getStaticProperty(String className, String fieldName) throws Exception
{
Class ownerClass = Class.forName(className);
Field field = ownerClass.getField(fieldName);
Object property = field.get(ownerClass);
return property;
}
3. 执行某对象的方法
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception
{
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++)
{
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(owner, args);
}
4. 执行某个类的静态方法
public Object invokeStaticMethod(String className, String methodName,Object[] args) throws Exception
{
Class ownerClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++)
{
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(null, args);
}
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
5. 新建实例
public Object newInstance(String className, Object[] args) throws Exception
{
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++)
{
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。
6. 判断是否为某个类的实例
public boolean isInstance(Object obj, Class cls)
{
return cls.isInstance(obj);
}
7. 得到数组中的某个元素
public Object getByArray(Object array, int index)
{
return Array.get(array,index);
}
8. 暴力反射
Class b = Math.class;
Constructor[]cc = b.getDeclaredConstructors();
Math t1=null,t2=null;
for(int i =0;i<cc.length;i++) {
<span style="white-space:pre"> </span>cc[i].setAccessible(true);
<span style="white-space:pre"> </span>t1 = (Math)cc[i].newInstance();
<span style="white-space:pre"> </span>t2 = (Math)cc[i].newInstance();
<span style="white-space:pre"> </span>System.out.println(t1.abs(1));
<span style="white-space:pre"> </span>System.out.println(t2.abs(1));
}
System.out.println(t1 == t2);
9. 反射实例：可反射整个类
package com.ren.day1;
/*
* Author:renpignqing
* 2013-07-28 02:11:15
* Version:1.0.0
* Last modify date:2013-07-28 02:11:16
* */
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class ReflectTool {
/**
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) {
String className = "java.lang.String";
Class cla = null;
Class reType = null;
Class superClass = null;
// 如果用户没有在命令行输入类名，则提示用户输入类名
if (!(args.length > 0)) {
out("Please enter a class name:");
Scanner keyIn = new Scanner(System.in);
className = keyIn.nextLine();
} else {
className = args[0];
}
//
//获取该类对象
try {
cla = Class.forName(className);
superClass = cla.getSuperclass();
} catch (ClassNotFoundException e) {
outln(className + "Not class found!");
}
outln("\t-------- "+ className + " reflect result--------\n");
//类
int modi = cla.getModifiers();
out(Modifier.toString(modi));
if (modi > 0) {
out(" ");
}
out(className);
//父类
if (superClass != null && superClass != Object.class) {
out(" extends ");
outln(superClass + " {");
} else {
outln(" {");
}
printConstructor(cla);
printMethod(cla);
printField(cla);
out("}");
}
//打印构造方法
public static void printConstructor(Class cla) {
/*
*步骤：
* 1、通过getConstructors()方法获取所以构造器
* 2、对构造器数组迭代
* 3、迭代过程中，通过getModifiers()方法获取修饰符，返回int
* 3、通过Modifier.toString()方法解析修饰符
* 4、通过getName获取该类名称
* 5、通过getParameterTypes()方法获取所以参数
* 6、迭代参数数组
* 7、如果参数数组大于1，说明不止一个参数，则在参数后面加上分隔符
* 8、否则不打印分隔符
* */
outln("\t-------------Constructor-------------");
// Class par[] = null;
// Constructor[] constructors = cla.getConstructors();
// for (Constructor constructor : constructors) {
// int mod = constructor.getModifiers();
// out("\t" + Modifier.toString(mod) + " ");
//
// out(cla.getName() + " (");
//
// //打印参数
// par = constructor.getParameterTypes();
// for (Class p : par) {
// if(par.length > 1) {
// out(p.getName() + ", ");
// } else {
// outln(p.getName() + ")");
// }
//// outln(" {}");
// }
// }
// outln("");
//参数
Class par[] = null;
Constructor[] constructors = cla.getConstructors();
for (Constructor constructor : constructors) {
int mod = constructor.getModifiers();
out("\t" + Modifier.toString(mod) + " ");
par = constructor.getParameterTypes();
out(cla.getName() + " (");
for (int i = 0; i < par.length; i++) {
if (par[i].isArray()) {
if (i > 0)
out(",");
out(par[i].getComponentType().getName() + "[]");
} else {
if (i > 0)
out(",");
out(par[i].getName());
}
}
outln(");");
}
}
//打印域
public static void printField(Class cla) {
/*
* 步骤：
* 1、通过cla.getFields()方法获取所以域
* 2、迭起域数组
* 3、迭代过程中，通过getModifiers()方法获取修饰符，返回int
* 4、通过Modifier.toString()方法解析修饰符
* 5、通过getType()方法获取该域的数据类型
* 6、通过getName获取该域名称
* */
outln("\t-------------Field-------------");
Field[] fields = cla.getFields();
for (Field field : fields) {
int mod = field.getModifiers();
out("\t" + Modifier.toString(mod) + " ");
out(field.getType() + " ");
outln(field.getName() + ";");
}
}
//打印方法
public static void printMethod(Class cla) {
/*
* 步骤：
* 1、通过getMethods()方法获取所以方法
* 2、迭代方法数组
* 3、迭代过程中，通过getModifiers()方法获取修饰符，返回int
* 4、通过Modifier.toString()方法解析修饰符
* 5、获取返回类型，如果返回类型是一个数组，则在获取数组中的内容类型的名字
* 6、通过getParameterTypes()方法获取所所有参数
* 7、迭代参数数组，如果参数大于而则输出分隔符，如果参数是一个数组，则获取数组中内容类型的名字
* */
outln("\t-------------Method-------------");
Class reType = null;
//方法
// Method[] methods = cla.getMethods();
Method[] methods = cla.getDeclaredMethods();
for (Method method : methods) {
//标识符
int mod = method.getModifiers();
out("\t" + Modifier.toString(mod) + " ");
//返回类型
reType = method.getReturnType();
if (reType.isArray()) { //如果是一个数组，则要在获取数组的class对象，再获取name
out(reType.getComponentType().getName() + "[] ");
} else {
out(reType.getName() + " ");
}
out(method.getName() + " (");
//参数
Class[] pTypes = method.getParameterTypes();
for (Class class1 : pTypes) {
if (class1.isArray()) { //如果是一个数组，则要在获取数组的class对象，再获取name
if (pTypes.length > 1) { //如果数组长度大于2表示后面还有参数，所以在后面加"," 分割参数
out(class1.getComponentType().getName() + "[], ");
} else {
out(class1.getComponentType().getName() + "[]");
}
} else {
if (pTypes.length > 1) {
out(class1.getName() + ", ");
} else {
out(class1.getName());
}
}
}
outln(");");
}
outln("");
}
// 输出
public static void outln(Object obj) {
System.out.println(obj);
}
public static void out(Object obj) {
System.out.print(obj);
}
}