JAVA反射机制
转自：http://blog.csdn.net/stevenhu_223/article/details/9286121
前言：我们知道，类和类的成员变量及方法都是要求有权限控制的(public、protected、private)；而当类中的信息封装为私有时，外部对该类中私有的信息是没有访问权限的，也就是说当该类里的内容信息均受private权限控制时，外部想要获取和处理该类里的私有信息是几乎不可能的；但是，有时候这种需求是有的，而当我们非得需要去动用别的类里封装的私有信息时，java的反射机制就起到了非常关键的作用了；
java反射机制的实现主要由三个类来主导：它们分别是Class、Field、Method；
1. Class：
java在编译和运行时，会将需要被编译和运行的所有类加载进类加载器，每个类被加载之后，系统就会为该类生成一个对应的Class对象，通过该Class对象就可以访问到java虚拟机中的这个类，进而在运行时对这个被访问的类进行信息的获取和处理(当然，不管被访问的这个类里的信息是否私有的)；通俗的讲，Class对象间接代表了它对应的类，通过这个Class对象，我们就可以大刀阔斧地去执行反射机制的实现；
获取Class对象主要有三种方式：
1). 调用Class类的forName(String name)静态方法，参数name为Class对应的类的全名(包括包名)；
比如我们要创建Gesture这个类对应的Class对象：Class<Gesture> mClass = Class.forName(“android.gesture.Gesture”);
android.gesture为Gesture的包名，Class<Gesture>中的Gesture表示得到的是Gesture类型对应的Class对象，<>中的Gesture也可为通配符?表示，如：Class<?>mClass = Class.forName(“android.gesture.Gesture”);
2). 调用类的class属性得到类对应的Class对象。如：Class<?>mClass = Gesture.class; (一般建议用这种方式得到Class对象)
3).调用类的实例化对象的getClass()方法。特别说明的是，getClass()是java类的始祖Object类的方法，所以，所有java对象都可以调用该方法；如mGesture是Gesture类型的对象，Class<?> mClass = mGesture.getClass()得到的是Gesture类对应的Class对象
那么在得到对应类的Class对象对应后，我们就可以通过该Class对象得到它所对应的类的一些信息，比如该类的构造函数、成员(属性)、方法(函数)；
Class类提供的相关接口介绍：(注：在表中，Class对象对应的类，姑且称为目标类)
| 接口 | 返回类型 | 接口功能实现 |
| getPackage() | Package | 得到目标类的包名对应的Package对象 |
| getCanonicalName() | String | 得到目标类的全名(包名+类名) |
| getName() | String | 同getCanonicalName() |
| getClassLoader() | ClassLoader | 得到加载目标类的ClassLoader对象 |
| getClasses() | Class<?>[] | 得到目标类中的所有的public内部类以及public内部接口所对应的Class对象 |
| getDeclaredClasses() | Class<?>[] | 同getClasses()，但不局限于public修饰，只要是目标类中声明的内部类和接口均可 |
| getConstructors() | Constructor<?>[] | 得到目标类的所有public构造函数对应的Constructor对象 |
| getDeclaredConstructors() | Constructor<?>[] | 同getConstructors()，但不局限于public修饰，只要是目标类中声明的构造函数均可 |
| getField(String arg) | Field | 得到目标类中指定的某个public属性对应的Field对象 |
| getDeclaredField(String arg) | Field | 同getField，但不局限于public修饰，只要是目标类中声明的属性均可 |
| getFields() | Field[] | 得到目标类中所有的public属性对应的Field对象 |
| getDeclaredFields() | Field[] | 同getFields()，但不局限于public修饰的属性 |
| getMethod(String arg0, Class<?>… arg1) | method | 得到目标类中指定的某个public方法对应的Method对象 |
| getDeclaredMethod(String arg0, Class<?>… arg1) | Method | 同getMethod，但不局限于public修饰的方法 |
| getMethods() | Method[] | 得到目标类中所有的public方法对应的Method对象 |
| getDeclaredMethods() | Method[] | 同getMethods()，但不局限于public修饰的方法 |
| getEnclosingClass() | Class | 得到目标类所在的外围类的Class对象 |
| getGenericInterfaces() | Type[] | 得到目标类实现的接口对应的Type对象 |
| getGenericSuperclass() | Type | 得到目标类继承的父类所对应的Type对象 |
| getInterfaces() | Class<?>[] | 得到目标类实现的接口所对应的Class对象 |
| getSuperclass() | Class | 得到目标类继承的父类所对应的Class对象 |
| isMemberClass() | boolean | 目标类是否为成员类 |
| cisAnonymousClass() | boolean | 目标类是否为匿名类 |
2.Field：
我们知道一般类里包含有属性(成员)和方法(函数)，竟然Class是描述类的信息，那么类其它部分应该会对应有描述它们的东东，而Field类型的对象就是描述Class对象对应类的出现包括public、protected、private属性)；一个Field对象对应描述一个类的属性；
通过上文对Class的介绍，我们知道Class提供了四种接口函数可以得到对应属性的Field：
1). getField(String name)：返回类型为Field，name为类中的属性名，得到的是描述类中的一个public属性对应的Field对象；如Field mField =mClass.getField(“mGestureID”) 得到的是Gesture类中的一个public属性mGestureID对应的Field对象；
2). getFields()：返回类型为Field类型数组，得到的是描述类中的所有public属性对应的所有Field对象；
3). getDeclaredField(String name)：同getField(String name)，只不过得到的Field对象描述的不只是public属性，
还包括protected、private属性，也是说只要是在类中声明的属性；
4). getDeclaredFields()：getFields()，得到的是描述类中声明的所有属性(public、protected、private)对应的Field对象；
Field类的相关函数接口介绍：
Field类提供的相关接口介绍：(注：在表中，Field对象对应的属性，姑且称为目标属性)
| 接口 | 返回类型 | 接口功能实现 |
| setAccessible(boolean flag) | void | 参数为true，只要是在类中声明的目标属性均可访问，为false，只有public目标属性可访问 |
| set(Object object, Object value) | void | 给目标属性设置值(private、protected属性均不能访问，但可以通过先调用setAccessible(true)实现访问)，第一个参数为目标属性所在类的对象，第二个参数为传入的值 |
| get(Object object) | Object | 得到目标属性的值(private、protected属性均不能访问，但可以通过调用setAccessible(true)实现访问)，参数为目标属性所在类的对象 |
| setBoolean(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为boolean |
| getBoolean(Object object) | boolean | 同get(Object object)，只不过得到的数据类型为boolean |
| setByte(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为byte |
| getByte(Object object) | byte | 同get(Object object)，只不过得到的数据类型为byte |
| setShort(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为short |
| getShort(Object object) | short | 同get(Object object)，只不过得到的数据类型为short |
| setInt(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为int |
| getInt(Object object) | int | 同get(Object object)，只不过得到的数据类型为int |
| setLong(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为long |
| getLong(Object object) | long | 同get(Object object)，只不过得到的数据类型为long |
| setFloat(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为float |
| getFloat(Object object) | float | 同get(Object object)，只不过得到的数据类型为float |
| setDouble(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为double |
| getDouble(Object object) | double | 同get(Object object)，只不过得到的数据类型为double |
| setChar(Object object, boolean value) | void | 同set(Object object, Object value)，只不过操作的数据类型为char |
| getChar(Object object) | char | 同get(Object object)，只不过得到的数据类型为char |
| getName() | String | 得到目标属性的名字，不局限于private修饰符，只要是类中声明的属性 |
| getGenericType() | Type | 得到目标属性的类型，不局限于private修饰符 |
| getType() | Class<?> | 得到目标属性的类型对应的Class对象 |
| getModifiers() | int | 得到目标属性的修饰符值(private为2、protected为4、public为1、static为8、final为16) |
| getDeclaringClass() | Class<?> | 得到目标属性所在类对应的Class对象 |
下面就以一个示例代码来验证Field表中的函数接口的实现，如下：
1). FieldBeReflected.java（被反射的类）
1 package com.stevenhu.field; 2 3 public class FieldBeReflected 4 { 5 private static String name; 6 private static String name1; 7 private boolean mBoolean = true; 8 private final byte mByte = 111; 9 private static final short mShort = 22; 10 protected static int mInt; 11 protected static long mLong; 12 protected static float mFloat; 13 protected static double mDouble; 14 public static char mChar; 15 16 }
2). ReflectField.java（执行反射调用的类）
1 package com.stevenhu.reflection.test; 2 import java.lang.reflect.Field; 3 import java.lang.reflect.InvocationTargetException; 4 import java.lang.reflect.Method; 5 import java.lang.reflect.Type; 6 7 import com.stevenhu.field.FieldBeReflected; 8 9 public class ReflectField 10 { 11 12 public static void main(String[] args) 13 { 14 /*1.Class<?> clazz = Class.forName("com.stevenhu.field.FieldBeReflected"); 15 *2.FieldBeReflected mFieldBeReflected = new FieldBeReflected(); 16 * Class<?> clazz = mFieldBeReflected.getClass(); 17 */ 18 Class<?> clazz = FieldBeReflected.class; 19 20 try { 21 Field fName = clazz.getDeclaredField("name"); 22 Field fBoolean = clazz.getDeclaredField("mBoolean"); 23 Field fByte = clazz.getDeclaredField("mByte"); 24 Field fShort = clazz.getDeclaredField("mShort"); 25 Field fInt = clazz.getDeclaredField("mInt"); 26 Field fLong = clazz.getDeclaredField("mLong"); 27 Field fFloat = clazz.getDeclaredField("mFloat"); 28 Field fDouble = clazz.getDeclaredField("mDouble"); 29 Field fChar = clazz.getDeclaredField("mChar"); 30 31 /* 32 * 参数为true，只要是在类中声明的目标属性均可访问， 33 * 为false，则被反射类和反射类在同一个包中时，private目标属性不可访问， 34 * 不在同一个包中时，private、protected目标属性均不可访问 35 */ 36 fName.setAccessible(true); 37 38 /*给目标属性设置值(private属性不能访问，但可以通过先调用setAccessible(true)实现访问), 39 * 由于ReflectField类中的name属性是静态的(static)，所以方法的第一个实参传入的是 40 * 目标属性所在类对应的Class对象clazz，也可以是类的实例clazz.newInstance(); 41 */ 42 fName.set(clazz, "reflection"); 43 //得到目标属性的值(private属性不能访问，但可以通过调用setAccessible(true)实现访问) 44 String name = (String) fName.get(clazz); 45 System.out.println(name); 46 47 fBoolean.setAccessible(true); 48 /*得到目标属性的布尔值，由于ReflectField类中的mBoolean属性是非静态的， 49 * 所以此处的传入实参为目标属性所在类的实例clazz.newInstance() 50 */ 51 boolean mBoolean = fBoolean.getBoolean(clazz.newInstance()); 52 System.out.println(mBoolean); 53 54 fByte.setAccessible(true); 55 //得到目标属性的Byte类型值 56 byte mByte = fByte.getByte(clazz.newInstance()); 57 System.out.println(mByte); 58 59 fShort.setAccessible(true); 60 //得到目标属性的short整型值 61 short mShort = fShort.getShort(clazz); 62 System.out.println(mShort); 63 64 fInt.setAccessible(true); 65 //给目标属性设置整型值 66 fInt.setInt(clazz, 222); 67 //得到目标属性的整型值 68 int mInt = fInt.getInt(clazz); 69 System.out.println(mInt); 70 71 fLong.setAccessible(true); 72 //给目标属性设置Long整型值 73 fLong.setLong(clazz, 2222); 74 //得到目标属性的Long整型值 75 Long mLong = fLong.getLong(clazz); 76 System.out.println(mLong); 77 78 fFloat.setAccessible(true); 79 //给目标属性设置float类型值 80 fFloat.setFloat(clazz, 22222); 81 //得到目标属性的float类型值 82 float mFloat = fFloat.getFloat(clazz); 83 System.out.println(mFloat); 84 85 fDouble.setAccessible(true); 86 //给目标属性设置double类型值 87 fDouble.setDouble(clazz, 222.222); 88 //得到目标属性的double类型值 89 double mDouble = fDouble.getDouble(clazz); 90 System.out.println(mDouble); 91 92 //给目标属性设置字符值(private、protected属性不能访问) 93 fChar.setChar(clazz, \'a\'); 94 //得到目标属性的字符值(private、protected属性不能访问) 95 char mChar = fChar.getChar(clazz); 96 System.out.println(mChar); 97 98 //目标属性的名字，不局限于修饰符，只要是类中声明的属性 99 String name1 = fName.getName(); 100 System.out.println(name1); 101 //目标属性的类型，不局限于修饰符 102 Type type = fName.getGenericType(); 103 System.out.println(type); 104 //目标属性的类型对应的Class对象 105 Class<?> clazz1 = fName.getType(); 106 System.out.println(clazz1); 107 //目标属性所在类对应的Class对象 108 Class<?> clazz2 = fName.getDeclaringClass(); 109 System.out.println(clazz2); 110 //目标属性的权限修饰值(private为2、protected为4、public为1) 111 int modifier = fName.getModifiers(); 112 int modifier1 = fByte.getModifiers(); 113 int modifier2 = fShort.getModifiers(); 114 System.out.println(modifier); 115 System.out.println(modifier1); 116 System.out.println(modifier2); 117 118 System.out.println(fName.isAccessible()); 119 System.out.println(fChar.isAccessible()); 120 121 } catch (NoSuchFieldException e) { 122 // TODO Auto-generated catch block 123 e.printStackTrace(); 124 } catch (SecurityException e) { 125 // TODO Auto-generated catch block 126 e.printStackTrace(); 127 } catch (IllegalArgumentException e) { 128 // TODO Auto-generated catch block 129 e.printStackTrace(); 130 } catch (IllegalAccessException e) { 131 // TODO Auto-generated catch block 132 e.printStackTrace(); 133 } catch (InstantiationException e) { 134 // TODO Auto-generated catch block 135 e.printStackTrace(); 136 } 137 } 138 139 }
3. Method：
同Fiel一样，一个Method对象对应描述一个类的方法；
Class对象也提供了四种接口函数得到对应方法的Method对象，如下：
1). getMethod(String name, Class<?>… parameterTypes)：返回类型为Method，第一个参数name为类中的方法名，第二个参数为可变参数，传入的是参数类型对应的Class对象(方法的参数可能为多个的情况)；该函数得到的是描述类中的一个public方法对应的Method对象；
2). getMethods()：返回类型为Method类型数组，得到的是描述类中的所有public方法对应的Method对象；
3). Method getDeclaredMethod(String name, Class<?>… parameterTypes)：同getMethod(String name, Class<?>… parameterTypes)，只不过得到的Method对象描述的不只是public方法， 还包括
protected、private方法，也是说只要是在类中声明的方法；
4). getDeclaredMethods()：getMethods()，得到的是描述类中声明的所有方法(public、protected、private)对应的FMethod对象；
Method类的相关函数接口介绍：
Method类提供的相关接口介绍：(注：在表中，Method对象对应的方法，姑且称为目标方法)
| 接口 | 返回类型 | 接口功能实现 |
| setAccessible(boolean flag) | void | 参数为true，只要是在类中声明的目标方法均可访问，为false，只有public目标属性可访问 |
| invoke(Object receiver, Object… args) | Object | 动态执行调用目标方法，第一个参数为Class对象或者类的实例，第二个参数为可变实参的对象(多个实参) |
| getDeclaringClass() | Class<?> | 得到目标方法所在类对应的Class对象 |
| getExceptionTypes() | Class<?> | 得到目标方法抛出的异常类型对应的Class对象 |
| getGenericExceptionTypes() | Type[] | 得到目标方法抛出的异常类型对应的Type对象 |
| getReturnType() | Class<?> | 得到目标方法返回类型对应的Class对象 |
| getGenericReturnType() | Type | 得到目标方法返回类型对应的Type对象 |
| getParameterTypes() | Class<?>[] | 得到目标方法各参数类型对应的Class对象 |
| getGenericParameterTypes() | Type[] | 得到目标方法各参数类型对应的Type对象 |
| getModifiers() | int | 得到目标方法修饰符的值 |
| getName() | String | 得到目标方法的名字 |
下面就以一个示例代码来验证Method表中的函数接口的实现，如下：
1). MethodBeReflected.java（被反射的类）
1 package com.stevenhu.method; 2 3 public class MethodBeReflected 4 { 5 6 private static String mName; 7 private static int mAge; 8 private static float mWeight; 9 10 private String getmName() 11 { 12 return mName; 13 } 14 15 protected void setmName(String mName) 16 { 17 this.mName = mName; 18 } 19 20 protected static int getmAge() 21 { 22 return mAge; 23 } 24 25 private static void setmAge(int age) 26 { 27 mAge = age; 28 } 29 30 private float getmWeight() throws Exception, NoSuchMethodException, SecurityException 31 { 32 return mWeight; 33 } 34 35 protected void setmWeight(float mWeight) 36 { 37 this.mWeight = mWeight; 38 } 39 40 private void setAllValues(String name, int age, float weight) 41 { 42 this.mName = name; 43 this.mAge = age; 44 this.mWeight = weight; 45 } 46 }
2)ReflectMethod.java（执行反射的类）
1 package com.stevenhu.reflection.test; 2 3 import java.lang.reflect.InvocationTargetException; 4 import java.lang.reflect.Method; 5 import java.lang.reflect.Type; 6 7 import com.stevenhu.method.MethodBeReflected; 8 9 public class ReflectMethod 10 { 11 12 /** 13 * @param args 14 */ 15 public static void main(String[] args) 16 { 17 // TODO Auto-generated method stub 18 19 Class<?> clazz = MethodBeReflected.class; 20 21 try 22 { 23 //第一个实参为方法名，第二个实参为方法参数类型对应的class对象 24 Method nameMethod = clazz.getDeclaredMethod("setmName", String.class); 25 Method ageMethod = clazz.getDeclaredMethod("setmAge", int.class); 26 Method weightMethod = clazz.getDeclaredMethod("setmWeight", float.class); 27 Method allValuesMethod = clazz.getDeclaredMethod("setAllValues", new Class[]{String.class, int.class, float.class}); 28 29 nameMethod.setAccessible(true); 30 //调用setmName方法，给ReflectMethod类中的属性mName赋值为"stevenhu" 31 nameMethod.invoke(clazz.newInstance(), "lisa"); 32 nameMethod = clazz.getDeclaredMethod("getmName", null); 33 nameMethod.setAccessible(true); 34 //调用getmName方法，得到mName的值 35 String name1 = (String) nameMethod.invoke(clazz.newInstance(), null); 36 System.out.println(name1); 37 38 ageMethod.setAccessible(true); 39 /*调用setmAge方法设置年龄，由于该方法是静态方法，所以第一个实参可为类的Class对象clazz， 40 * 也可以是类的对象clazz.newInstance()； 41 */ 42 ageMethod.invoke(clazz, 21); 43 ageMethod = clazz.getDeclaredMethod("getmAge", null); 44 ageMethod.setAccessible(true); 45 //调用getmAge方法，得到之前设置的年龄 46 int age1 = (Integer) ageMethod.invoke(clazz, null); 47 System.out.println(age1); 48 49 weightMethod.setAccessible(true); 50 //调用setmWeight方法，设置体重 51 weightMethod.invoke(clazz.newInstance(), new Float(50.5)); 52 weightMethod = clazz.getDeclaredMethod("getmWeight",null); 53 weightMethod.setAccessible(true); 54 //调用getmWeight方法，得到之前设置的体龄 55 float weight1 = (Float) weightMethod.invoke(clazz.newInstance(), null); 56 System.out.println(weight1); 57 58 allValuesMethod.setAccessible(true); 59 /*调用ReflectMethod的setAllValues方法赋值 60 * 注:此处不能直接传入实参63.5；浮点型必须创建Float对象 61 * 整型和字符串可创建Integer、String对象，也可以不创建 62 */ 63 //allValuesMethod.invoke(clazz.newInstance(), new String("stevenhu"), new Integer(23), new Float(63.5)); 64 allValuesMethod.invoke(clazz.newInstance(), "stevenhu", 23, new Float(63.5)); 65 66 nameMethod = clazz.getDeclaredMethod("getmName", null); 67 nameMethod.setAccessible(true); 68 String name2 = (String) nameMethod.invoke(clazz.newInstance(), null); 69 System.out.println(name2); 70 71 ageMethod = clazz.getDeclaredMethod("getmAge", null); 72 ageMethod.setAccessible(true); 73 int age2 = (Integer) ageMethod.invoke(clazz.newInstance(), null); 74 System.out.println(age2); 75 76 weightMethod = clazz.getDeclaredMethod("getmWeight", null); 77 weightMethod.setAccessible(true); 78 float weight2 = (Float) weightMethod.invoke(clazz.newInstance(), null); 79 System.out.println(weight2); 80 81 //得到目标方法所在类对应的Class对象 82 Class<?> clazz1 = weightMethod.getDeclaringClass(); 83 84 //得到目标方法抛出的异常类型对应的Class对象 85 Class<?>[] clazzs1 = weightMethod.getExceptionTypes(); 86 for (Class cl : clazzs1) 87 { 88 System.out.println(cl); 89 } 90 //得到目标方法抛出的异常类型对应的Type对象 91 Type[] types1 = weightMethod.getGenericExceptionTypes(); 92 //得到目标方法返回类型对应的Class对象 93 Class<?> clazz2 = nameMethod.getReturnType(); 94 //得到目标方法返回类型对应的Type对象 95 Type type = nameMethod.getGenericReturnType(); 96 //得到目标方法各参数类型对应的Class对象 97 Class<?>[] clazzs2 = allValuesMethod.getParameterTypes(); 98 //得到目标方法各参数类型对应的Type对象 99 Type[] types2 = allValuesMethod.getGenericParameterTypes(); 100 //得到目标方法修饰符的值 101 int modifier = ageMethod.getModifiers(); 102 System.out.println(modifier); 103 //得到目标方法的名字 104 String methodName = nameMethod.getName(); 105 System.out.println(nameMethod.isVarArgs()); 106 107 } catch (NoSuchMethodException e) 108 { 109 // TODO Auto-generated catch block 110 e.printStackTrace(); 111 } catch (SecurityException e) 112 { 113 // TODO Auto-generated catch block 114 e.printStackTrace(); 115 } catch (IllegalAccessException e) { 116 // TODO Auto-generated catch block 117 e.printStackTrace(); 118 } catch (IllegalArgumentException e) { 119 // TODO Auto-generated catch block 120 e.printStackTrace(); 121 } catch (InvocationTargetException e) { 122 // TODO Auto-generated catch block 123 e.printStackTrace(); 124 } catch (InstantiationException e) { 125 // TODO Auto-generated catch block 126 e.printStackTrace(); 127 } 128 } 129 130 }
有关反射知识点的介绍到此结束，实例代码下载链接地址如下：
版权声明：本文为zl1991原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。