本篇文章已授权微信公众号guolin_blog(郭霖)独家发布
对于Java反射，平常工作中虽然经常用到，但一直以来都没有系统总结过，所以趁着目前有空总结一下，加深一下理解。
如果发现谬误，欢迎各位批评指正。
本文相关知识点大部分总结自Oracle官方文档，对于英文比较好的朋友，建议直接阅读原文档。
按例，首先描述定义一下。
Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts, within security restrictions.
通过反射，Java代码可以发现有关已加载类的字段，方法和构造函数的信息，并可以在安全限制内对这些字段，方法和构造函数进行操作。
简而言之，你可以在运行状态中通过反射机制做到：
- 对于任意一个类，都能够知道这个类的所有属性和方法；
- 对于任意一个对象，都能够调用它的任意一个方法和属性;
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
在我看来我们平时使用Java反射主要涉及两个类(接口)Class， Member，如果把这两个类搞清楚了，反射基本就ok了。
Class
提到反射就不得不提到Class，Class可以说是反射能够实现的基础；注意这里说的Class与class关键字不是同一种东西。class关键字是在声明java类时使用的；而Class 是java JDK提供的一个类,完整路径为 java.lang.Class，本质上与Math, String 或者你自己定义各种类没什么区别。
public final class Class<T> implements java.io.Serializable, GenericDeclaration, Type, AnnotatedElement {
...
}
那Class到底在反射中起到什么作用呢？
For every type of object, the Java virtual machine instantiates an immutable instance of
java.lang.Classwhich provides methods to examine the runtime properties of the object including its members and type information.Classalso provides the ability to create new classes and objects. Most importantly, it is the entry point for all of the Reflection APIs.
对于每一种类，Java虚拟机都会初始化出一个Class类型的实例，每当我们编写并且编译一个新创建的类就会产生一个对应Class对象，并且这个Class对象会被保存在同名.class文件里。当我们new一个新对象或者引用静态成员变量时，Java虚拟机(JVM)中的类加载器系统会将对应Class对象加载到JVM中，然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。
比如创建编译一个Shapes类，那么，JVM就会创建一个Shapes对应Class类的Class实例，该Class实例保存了Shapes类相关的类型信息，包括属性，方法，构造方法等等，通过这个Class实例可以在运行时访问Shapes对象的属性和方法等。另外通过Class类还可以创建出一个新的Shapes对象。这就是反射能够实现的原因，可以说Class是反射操作的基础。
需要特别注意的是，每个class（注意class是小写，代表普通类）类，无论创建多少个实例对象，在JVM中都对应同一个Class对象。
下面就通过一个简单的例子来说明如何通过反射实例化一个对象。
public class Animal {
private String name;
private int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Animal : name = " + name + " age = " + age;
}
}
public class TestReflection{
private static final String TAG = "Reflection";
public void testReflection(){
//获取Animal类的Class对象
Class c = Animal.class;
try {
//通过Class对象反射获取Animal类的构造方法
Constructor constructor = c.getConstructor(String.class, int.class);
//调用构造方法获取Animal实例
Animal animal = (Animal) constructor.newInstance( "Jack", 3);
//将构造出来的Animal对象打印出来
Log.d(TAG, animal.toString());
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
下面我们来看下打印值
03-28 20:12:00.958 2835-2835/? D/Reflection: Animal : name = Jack age = 3
可以看出我们确实成功构造出了Animal对象，而且在这过程中Class功不可没。
有人说你这也太费事了，都知道Animal对象了，我分分钟就能给你new出来了。
Animal animal = new Animal("Jack", 3);
没错！
但是如果并不能直接导入Animal类呢，如果构造方法都是private的呢？这个时候反射就能大展身手了。
如何获取Class
说Class是反射能够实现的基础的另一个原因是：Java反射包java.lang.reflect中的所有类都没有public构造方法，要想获得这些类实例，只能通过Class类获取。所以说如果想使用反射，必须得获得Class对象。
下面列举了几种能够获取Class对象的方法。
-
Object.getClass()
通过对象实例获取对应Class对象，如
//Returns the Class for String
Class c = "foo".getClass();
enum E { A, B }
//Returns the Class corresponding to the enumeration type E.
Class c = A.getClass();
byte[] bytes = new byte[1024];
//Returns the Class corresponding to an array with component type byte.
Class c = bytes.getClass();
Set<String> s = new HashSet<String>();
//Returns the Class corresponding to java.util.HashSet.
Class c = s.getClass();
然而对于基本类型无法使用这种方法
boolean b;
Class c = b.getClass(); // compile-time error
-
The .class Syntax
通过类的类型获取Class对象,基本类型同样可以使用这种方法，如
//The `.class` syntax returns the Class corresponding to the type `boolean`.
Class c = boolean.class;
//Returns the Class for String
Class c = String.class;
-
Class.forName()
通过类的全限定名获取Class对象， 基本类型无法使用此方法
Class c = Class.forName("java.lang.String");
对于数组比较特殊
Class cDoubleArray = Class.forName("[D"); //相当于double[].class
Class cStringArray = Class.forName("[[Ljava.lang.String;"); //相当于String[][].class
-
TYPE Field for Primitive Type Wrappers
基本类型和void 类型的包装类可以使用TYPE字段获取
Class c = Double.TYPE; //等价于 double.class.
Class c = Void.TYPE;
-
Methods that Return Classes
另外还有一些反射方法可以获取Class对象，但前提是你已经获取了一个Class对象。
有点拗口，比如说你已经获取了一个类的Class对象，就可以通过反射方法获取这个类的父类的Class对象。
Class.getSuperclass()
获得给定类的父类Class
// javax.swing.JButton的父类是javax.swing.AbstractButton
Class c = javax.swing.JButton.class.getSuperclass();
类似方法还有：
Class.getClasses()
Class.getDeclaredClasses()
Class.getDeclaringClass()
Class.getEnclosingClass()
java.lang.reflect.Field.getDeclaringClass()
java.lang.reflect.Method.getDeclaringClass()
java.lang.reflect.Constructor.getDeclaringClass()
通过Class获取类修饰符和类型
我们知道类的声明一般如下表示
下面我们就以HashMap为例，通过一个Demo来说明如何获取这些信息
public class TestReflection {
private static final String TAG = "Reflection";
public void testReflection() {
Class<?> c = HashMap.class;
//获取类名
Log.d(TAG, "Class : " + c.getCanonicalName());
//获取类限定符
Log.d(TAG, "Modifiers : " + Modifier.toString(c.getModifiers()));
//获取类泛型信息
TypeVariable[] tv = c.getTypeParameters();
if (tv.length != 0) {
StringBuilder parameter = new StringBuilder("Parameters : ");
for (TypeVariable t : tv) {
parameter.append(t.getName());
parameter.append(" ");
}
Log.d(TAG, parameter.toString());
} else {
Log.d(TAG, " -- No Type Parameters --");
}
//获取类实现的所有接口
Type[] intfs = c.getGenericInterfaces();
if (intfs.length != 0) {
StringBuilder interfaces = new StringBuilder("Implemented Interfaces : ");
for (Type intf : intfs){
interfaces.append(intf.toString());
interfaces.append(" ");
}
Log.d(TAG, interfaces.toString());
} else {
Log.d(TAG, " -- No Implemented Interfaces --");
}
//获取类继承数上的所有父类
List<Class> l = new ArrayList<>();
printAncestor(c, l);
if (l.size() != 0) {
StringBuilder inheritance = new StringBuilder("Inheritance Path : ");
for (Class<?> cl : l){
inheritance.append(cl.getCanonicalName());
inheritance.append(" ");
}
Log.d(TAG, inheritance.toString());
} else {
Log.d(TAG, " -- No Super Classes --%n%n");
}
//获取类的注解(只能获取到 RUNTIME 类型的注解)
Annotation[] ann = c.getAnnotations();
if (ann.length != 0) {
StringBuilder annotation = new StringBuilder("Annotations : ");
for (Annotation a : ann){
annotation.append(a.toString());
annotation.append(" ");
}
Log.d(TAG, annotation.toString());
} else {
Log.d(TAG, " -- No Annotations --%n%n");
}
}
private static void printAncestor(Class<?> c, List<Class> l) {
Class<?> ancestor = c.getSuperclass();
if (ancestor != null) {
l.add(ancestor);
printAncestor(ancestor, l);
}
}
}
打印结果如下
03-29 15:04:23.070 27826-27826/com.example.ming.testproject D/Reflection: Class : java.util.HashMap
03-29 15:04:23.070 27826-27826/com.example.ming.testproject D/Reflection: Modifiers : public
03-29 15:04:23.071 27826-27826/com.example.ming.testproject D/Reflection: Parameters : K V
03-29 15:04:23.071 27826-27826/com.example.ming.testproject D/Reflection: Implemented Interfaces : java.util.Map<K, V> interface java.lang.Cloneable interface java.io.Serializable
03-29 15:04:23.071 27826-27826/com.example.ming.testproject D/Reflection: Inheritance Path : java.util.AbstractMap java.lang.Object
03-29 15:04:23.071 27826-27826/com.example.ming.testproject D/Reflection: -- No Annotations --
Member
Reflection defines an interface
java.lang.reflect.Memberwhich is implemented byjava.lang.reflect.Field,java.lang.reflect.Method, andjava.lang.reflect.Constructor.
对于Member接口可能会有人不清楚是干什么的，但如果提到实现它的三个实现类，估计用过反射的人都能知道。我们知道类成员主要包括构造函数，变量和方法，Java中的操作基本都和这三者相关，而Member的这三个实现类就分别对应他们。
java.lang.reflect.Field ：对应类变量
java.lang.reflect.Method ：对应类方法
java.lang.reflect.Constructor ：对应类构造函数
反射就是通过这三个类才能在运行时改变对象状态。下面就让我们通过一些例子来说明如何通过反射操作它们。
首先建一个测试类
public class Cat {
public static final String TAG = Cat.class.getSimpleName();
private String name;
@Deprecated
public int age;
public Cat(String name, int age){
this.name = name;
this.age = age;
}
public String getName(){
return name;
}
public void eat(String food){
Log.d(TAG, "eat food " + food);
}
public void eat(String... foods){
StringBuilder s = new StringBuilder();
for(String food : foods){
s.append(food);
s.append(" ");
}
Log.d(TAG, "eat food " + s.toString());
}
public void sleep(){
Log.d(TAG, "sleep");
}
@Override
public String toString() {
return "name = " + name + " age = " + age;
}
}
Field
通过Field你可以访问给定对象的类变量，包括获取变量的类型、修饰符、注解、变量名、变量的值或者重新设置变量值，即使变量是private的。
获取Field
Class提供了4种方法获得给定类的Field。
getDeclaredField(String name)
获取指定的变量（只要是声明的变量都能获得，包括private）
getField(String name)
获取指定的变量（只能获得public的）
getDeclaredFields()
获取所有声明的变量（包括private）
getFields()
获取所有的public变量获取变量类型、修饰符、注解
一个例子说明问题
public void testField(){
Class c = Cat.class;
Field[] fields = c.getDeclaredFields();
for(Field f : fields){
StringBuilder builder = new StringBuilder();
//获取名称
builder.append("filed name = ");
builder.append(f.getName());
//获取类型
builder.append(" type = ");
builder.append(f.getType());
//获取修饰符
builder.append(" modifiers = ");
builder.append(Modifier.toString(f.getModifiers()));
//获取注解
Annotation[] ann = f.getAnnotations();
if (ann.length != 0) {
builder.append(" annotations = ");
for (Annotation a : ann){
builder.append(a.toString());
builder.append(" ");
}
} else {
builder.append(" -- No Annotations --");
}
Log.d(TAG, builder.toString());
}
}
打印结果：
filed name = age type = int modifiers = public annotations = @java.lang.Deprecated()
filed name = name type = class java.lang.String modifiers = private -- No Annotations --
filed name = TAG type = class java.lang.String modifiers = public static final -- No Annotations --
-
获取、设置变量值
给定一个对象和它的成员变量名称，就能通过反射获取和改变该变量的值。
什么都不说了，没有什么是不能通过一个例子解决的， Easy~
仍然是上面的测试类，通过反射获取并改变Cat的name和age.
public void testField(){
Cat cat = new Cat("Tom", 2);
Class c = cat.getClass();
try {
//注意获取private变量时，需要用getDeclaredField
Field fieldName = c.getDeclaredField("name");
Field fieldAge = c.getField("age");
//反射获取名字, 年龄
String name = (String) fieldName.get(cat);
int age = fieldAge.getInt(cat);
Log.d(TAG, "before set, Cat name = " + name + " age = " + age);
//反射重新set名字和年龄
fieldName.set(cat, "Timmy");
fieldAge.setInt(cat, 3);
Log.d(TAG, "after set, Cat " + cat.toString());
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
嗯？竟然报错？
System.err: java.lang.IllegalAccessException: Class java.lang.Class<com.example.ming.testnestscrollview.TestReflection> cannot access private field java.lang.String com.example.ming.testnestscrollview.Cat.name of class java.lang.Class<com.example.ming.testnestscrollview.Cat>
System.err: at java.lang.reflect.Field.get(Native Method)
System.err: at com.example.ming.testnestscrollview.TestReflection.testField(TestReflection.java:22)
System.err: at com.example.ming.testnestscrollview.MainActivity.onCreate(MainActivity.java:17)
观察一下异常信息java.lang.IllegalAccessException，说我们没有权限操作变量name；回到Cat类中查看一下name变量。
private String name;
原来name变量是private，Java运行时会进行访问权限检查，private类型的变量无法进行直接访问，刚刚进行的反射操作并没有打破这种封装，所以我们依然没有权限对private属性进行直接访问。
难道就没有办法打破这种限制吗？必须有！强大的反射早已暗中为我们准备好了一切。
反射包里为我们提供了一个强大的类
-
java.lang.reflect.AccessibleObject
AccessibleObject为我们提供了一个方法 setAccessible(boolean flag)，该方法的作用就是可以取消 Java 语言访问权限检查。所以任何继承AccessibleObject的类的对象都可以使用该方法取消 Java 语言访问权限检查。（final类型变量也可以通过这种办法访问）
public final class Field extends AccessibleObject implements Member
Field正是AccessibleObject的子类，那么简单了，只要在访问私有变量前调用filed.setAccessible(true)就可以了
...
fieldName.setAccessible(true);
//反射获取名字, 年龄
String name = (String) fieldName.get(cat);
...
打印结果
TestReflection: before set, Cat name = Tom age = 2
TestReflection: after set, Cat name = Timmy age = 3
Bingo!
注意Method和Constructor也都是继承AccessibleObject，所以如果遇到私有方法和私有构造函数无法访问，记得处理方法一样。
Method
The
java.lang.reflect.Methodclass provides APIs to access information about a method's modifiers, return type, parameters, annotations, and thrown exceptions. It also be used to invoke methods.
这节主要介绍如何通过反射访问对象的方法。
-
获取Method
Class依然提供了4种方法获取Method:
getDeclaredMethod(String name, Class<?>... parameterTypes)
根据方法名获得指定的方法， 参数name为方法名，参数parameterTypes为方法的参数类型，如 getDeclaredMethod(“eat”, String.class)
getMethod(String name, Class<?>... parameterTypes)
根据方法名获取指定的public方法，其它同上
getDeclaredMethods()
获取所有声明的方法
getMethods()
获取所有的public方法
注意：获取带参数方法时，如果参数类型错误会报
NoSuchMethodException，对于参数是泛型的情况，泛型须当成Object处理（Object.class）
-
获取方法返回类型
getReturnType()获取目标方法返回类型对应的Class对象
getGenericReturnType()获取目标方法返回类型对应的Type对象
这两个方法有啥区别呢？- getReturnType()返回类型为Class，getGenericReturnType()返回类型为Type; Class实现Type。
- 返回值为普通简单类型如Object, int, String等，getGenericReturnType()返回值和getReturnType()一样
例如public String function1()
那么各自返回值为：
getReturnType() : class java.lang.String
getGenericReturnType() : class java.lang.String - 返回值为泛型
例如public T function2()
那么各自返回值为：
getReturnType() : class java.lang.Object
getGenericReturnType() : T - 返回值为参数化类型
例如public Class<String> function3()
那么各自返回值为：
getReturnType() : class java.lang.Class
getGenericReturnType() : java.lang.Class<java.lang.String>
其实反射中所有形如getGenericXXX()的方法规则都与上面所述类似。
获取方法参数类型
getParameterTypes()获取目标方法各参数类型对应的Class对象
getGenericParameterTypes()获取目标方法各参数类型对应的Type对象
返回值为数组，它俩区别同上 “方法返回类型的区别” 。获取方法声明抛出的异常的类型
getExceptionTypes()获取目标方法抛出的异常类型对应的Class对象
getGenericExceptionTypes()获取目标方法抛出的异常类型对应的Type对象
返回值为数组，区别同上获取方法参数名称
.class文件中默认不存储方法参数名称，如果想要获取方法参数名称，需要在编译的时候加上-parameters参数。(构造方法的参数获取方法同样)
//这里的m可以是普通方法Method，也可以是构造方法Constructor
//获取方法所有参数
Parameter[] params = m.getParameters();
for (int i = 0; i < params.length; i++) {
Parameter p = params[i];
p.getType(); //获取参数类型
p.getName(); //获取参数名称，如果编译时未加上`-parameters`，返回的名称形如`argX`, X为参数在方法声明中的位置，从0开始
p.getModifiers(); //获取参数修饰符
p.isNamePresent(); //.class文件中是否保存参数名称, 编译时加上`-parameters`返回true,反之flase
}
获取方法参数名称的详细信息请参考oracle的官方例子MethodParameterSpy
-
获取方法修饰符
方法与Filed等类似
method.getModifiers();
Ps：顺便多介绍几个Method方法
-
method.isVarArgs()//判断方法参数是否是可变参数
public Constructor<T> getConstructor(Class<?>... parameterTypes) //返回true
public Constructor<T> getConstructor(Class<?> [] parameterTypes) //返回flase
-
method.isSynthetic()//判断是否是复合方法，个人理解复合方法是编译期间编译器生成的方法，并不是源代码中有的方法 -
method.isBridge()//判断是否是桥接方法，桥接方法是 JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法。可以参考https://www.cnblogs.com/zsg88/p/7588929.html
-
通过反射调用方法
反射通过Method的invoke()方法来调用目标方法。第一个参数为需要调用的目标类对象，如果方法为static的，则该参数为null。后面的参数都为目标方法的参数值，顺序与目标方法声明中的参数顺序一致。
public native Object invoke(Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
还是以上面测试类Cat为例
注意：如果方法是private的，可以使用
method.setAccessible(true)方法绕过权限检查
Class<?> c = Cat.class;
try {
//构造Cat实例
Constructor constructor = c.getConstructor(String.class, int.class);
Object cat = constructor.newInstance( "Jack", 3);
//调用无参方法
Method sleep = c.getDeclaredMethod("sleep");
sleep.invoke(cat);
//调用定项参数方法
Method eat = c.getDeclaredMethod("eat", String.class);
eat.invoke(cat, "grass");
//调用不定项参数方法
//不定项参数可以当成数组来处理
Class[] argTypes = new Class[] { String[].class };
Method varargsEat = c.getDeclaredMethod("eat", argTypes);
String[] foods = new String[]{
"grass", "meat"
};
varargsEat.invoke(cat, (Object)foods);
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
e.printStackTrace();
}
被调用的方法本身所抛出的异常在反射中都会以
InvocationTargetException抛出。换句话说，反射调用过程中如果异常InvocationTargetException抛出，说明反射调用本身是成功的，因为这个异常是目标方法本身所抛出的异常。
Constructor
这节主要介绍如何通过反射访问构造方法并通过构造方法构建新的对象。
-
获取构造方法
和Method一样，Class也为Constructor提供了4种方法获取
getDeclaredConstructor(Class<?>... parameterTypes)
获取指定构造函数，参数parameterTypes为构造方法的参数类型
getConstructor(Class<?>... parameterTypes)
获取指定public构造函数，参数parameterTypes为构造方法的参数类型
getDeclaredConstructors()
获取所有声明的构造方法
getConstructors()
获取所有的public构造方法
构造方法的名称、限定符、参数、声明的异常等获取方法都与Method类似，请参照Method
-
创建对象
通过反射有两种方法可以创建对象：
java.lang.reflect.Constructor.newInstance()
Class.newInstance()
一般来讲，我们优先使用第一种方法；那么这两种方法有何异同呢？
-
Class.newInstance()仅可用来调用无参的构造方法；Constructor.newInstance()可以调用任意参数的构造方法。 -
Class.newInstance()会将构造方法中抛出的异常不作处理原样抛出;Constructor.newInstance()会将构造方法中抛出的异常都包装成InvocationTargetException抛出。 -
Class.newInstance()需要拥有构造方法的访问权限;Constructor.newInstance()可以通过setAccessible(true)方法绕过访问权限访问private构造方法。
例子在Method一节已经写过，这里直接截取过来
Class<?> c = Cat.class;
try {
Constructor constructor = c.getConstructor(String.class, int.class);
Cat cat = (Cat) constructor.newInstance( "Jack", 3);
} catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
e.printStackTrace();
}
注意：反射不支持自动封箱，传入参数时要小心（自动封箱是在编译期间的，而反射在运行期间）
数组和枚举
数组和枚举也是对象，但是在反射中，对数组和枚举的创建、访问和普通对象有那么一丢丢的不同，所以Java反射为数组和枚举提供了一些特定的API接口。
数组
-
数组类型
数组类型：数组本质是一个对象，所以它也有自己的类型。
例如对于int[] intArray，数组类型为class [I。数组类型中的[个数代表数组的维度，例如[代表一维数组，[[代表二维数组；[后面的字母代表数组元素类型，I代表int，一般为类型的首字母大写(long类型例外，为J)。
class [B //byte类型一维数组
class [S //short类型一维数组
class [I //int类型一维数组
class [C //char类型一维数组
class [J //long类型一维数组，J代表long类型，因为L被引用对象类型占用了
class [F //float类型一维数组
class [D //double类型一维数组
class [Lcom.dada.Season //引用类型一维数组
class [[Ljava.lang.String //引用类型二维数组
//获取一个变量的类型
Class<?> c = field.getType();
//判断该变量是否为数组
if (c.isArray()) {
//获取数组的元素类型
c.getComponentType()
}
-
创建和初始化数组
Java反射为我们提供了java.lang.reflect.Array类用来创建和初始化数组。
//创建数组， 参数componentType为数组元素的类型，后面不定项参数的个数代表数组的维度，参数值为数组长度
Array.newInstance(Class<?> componentType, int... dimensions)
//设置数组值，array为数组对象，index为数组的下标，value为需要设置的值
Array.set(Object array, int index, int value)
//获取数组的值，array为数组对象，index为数组的下标
Array.get(Object array, int index)
例子,用反射创建 int[] array = new int[]{1, 2}
Object array = Array.newInstance(int.class, 2);
Array.setInt(array , 0, 1);
Array.setInt(array , 1, 2);
注意：反射支持对数据自动加宽，但不允许数据narrowing(变窄?真难翻译)。意思是对于上述set方法，你可以在int类型数组中 set short类型数据，但不可以set long类型数据，否则会报IllegalArgumentException。
-
多维数组
Java反射没有提供能够直接访问多维数组元素的API，但你可以把多维数组当成数组的数组处理。
Object matrix = Array.newInstance(int.class, 2, 2);
Object row0 = Array.get(matrix, 0);
Object row1 = Array.get(matrix, 1);
Array.setInt(row0, 0, 1);
Array.setInt(row0, 1, 2);
Array.setInt(row1, 0, 3);
Array.setInt(row1, 1, 4);
或者
Object matrix = Array.newInstance(int.class, 2);
Object row0 = Array.newInstance(int.class, 2);
Object row1 = Array.newInstance(int.class, 2);
Array.setInt(row0, 0, 1);
Array.setInt(row0, 1, 2);
Array.setInt(row1, 0, 3);
Array.setInt(row1, 1, 4);
Array.set(matrix, 0, row0);
Array.set(matrix, 1, row1);
枚举
枚举隐式继承自java.lang.Enum，Enum继承自Object，所以枚举本质也是一个类，也可以有成员变量，构造方法，方法等；对于普通类所能使用的反射方法，枚举都能使用；另外java反射额外提供了几个方法为枚举服务。
Class.isEnum()
Indicates whether this class represents an enum type
Class.getEnumConstants()
Retrieves the list of enum constants defined by the enum in the order they're declared
java.lang.reflect.Field.isEnumConstant()
Indicates whether this field represents an element of an enumerated type
反射的缺点
没有任何一项技术是十全十美的，Java反射拥有强大功能的同时也带来了一些副作用。
-
性能开销
反射涉及类型动态解析，所以JVM无法对这些代码进行优化。因此，反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被执行的代码或对性能要求很高的程序中使用反射。 -
安全限制
使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行，如Applet，那么这就是个问题了。 -
内部曝光
由于反射允许代码执行一些在正常情况下不被允许的操作（比如访问私有的属性和方法），所以使用反射可能会导致意料之外的副作用－－代码有功能上的错误，降低可移植性。反射代码破坏了抽象性，因此当平台发生改变的时候，代码的行为就有可能也随着变化。
使用反射的一个原则：如果使用常规方法能够实现，那么就不要用反射。
