java反射机制允许在不显式调用类及类方法的前提下，实现创建类对象、调用类方法等一系列操作。

在使用反射机制时，如果遇到类方法的参数中含有数组，情况稍有不同。如果数组参数为基本数据类型，如String、int等，则相对简单：

Class> tmp = Class.forName("testReflection");

Method m = tmp.getMethod("test", new Class[]{String[].class});

m.invoke(tmp.newInstance(),new String[]{"hi"});

如果数组参数为复杂数据类型，情况就较为复杂，以自定义类数组参数为例，样例如下。希望用反射调用Person类的setParents方法，而setParents方法的参数为Relative对象的数组：

package com.ashu.test;

import java.lang.reflect.InvocationTargetException;

public class TestReflection {

public static void main(String[] args) throws ClassNotFoundException,

InstantiationException, IllegalAccessException,

IllegalArgumentException, SecurityException,

InvocationTargetException, NoSuchMethodException {

Class> relativeClass = Class.forName("com.ashu.test.Relative");

Object relativeFather = relativeClass.newInstance();

Object relativeMother = relativeClass.newInstance();

relativeClass.getMethod("setName", String.class).invoke(relativeFather,

"father");

relativeClass.getMethod("setName", String.class).invoke(relativeMother,

"mother");

Class> personClass = Class.forName("com.ashu.test.Person");

Object personObject = personClass.newInstance();

Class> relativeClassArray = Class

.forName(new Relative[] {}.getClass().getName());

Object[] temp = (Object[]) java.lang.reflect.Array.newInstance(

relativeClass, 2);

temp[0] = relativeFather;

temp[1] = relativeMother;

personClass.getMethod(

"setParents",

java.lang.reflect.Array.newInstance(relativeClass, 2)

.getClass()).invoke(personObject,

relativeClassArray.cast(temp));

personClass.getMethod("getParents").invoke(personObject);

}

}

class Person {

private Relative[] parents;

public void getParents() {

for (Relative r : parents)

r.getName();

}

public void setParents(Relative[] parents) {

this.parents = parents;

}

}

class Relative {

private String name;

public void getName() {

System.out.println(name);

}

public void setName(String name) {

this.name = name;

}

}

在反射的使用中，主要步骤有两个：

1、找到Person的setParents方法。在输入setParents的参数类时，不能直接用relativeClass，而应该用其数组形式。不能像基本数据类型那样直接加[]，只能通过new出数组，再getClass的方法来确定：java.lang.reflect.Array.newInstance(relativeClass, 2).getClass()

2、给setParents方法传参。由于参数类型为对象数组，如果直接用new Object[]{relativeFather, relativeMother}的形式会报错，此时需要进行先找到对象数组的类(new Relative[] {}.getClass())，再用这个类对new出来的Object数组进行强转，这也是本方法的核心。

反射中可能用到的两个比较特殊的类型，数组和枚举，分别对应java.lang.reflect.Array和java.lang.Enum，后者其实并不是反射类库包中的类，但是反射的基础类库里面有使用枚举类型的方法

数组

数组是由Java虚拟机实现(这一点很重要，这就是为什么JDK类库中没有数组对应的类型的原因，array也不是Java中的保留关键字，操作数组的底层方法都是native方法)，数组类型只有继承自java.lang.Object的方法，数组的length方法实际上并不属于数组类型的一部分，数组的length方法其实最终调用的是java.lang.reflect.Array#getLength()，注意到这个方法是native方法。java.lang.reflect.Array是基于反射操作数组的核心类。

使用反射方式就是使用java.lang.reflect.Array中的相关方法：

int[] arr = new int[10];

Class> c = Class.forName(cName);

Object o = Array.newInstance(c, n);

for (int i = 0; i < n; i++) {

String v = cVals[i];

Constructor ctor = c.getConstructor(String.class);

Object val = ctor.newInstance(v);

Array.set(o, i, val);

}

Object[] oo = (Object[]) o;

因为Java泛型擦除的问题，实际上我们使用Array#newInstance方法只能得到一个Object类型的结果实例，其实这个结果实例的类型就是ComponentType[]，这里只是返回了它的父类(Object)类型实例，因此我们可以直接强转，例如：

String[] strArray = (String[]) Array.newInstance(String.class, 3);

反射条件下，可以通过Class.forName()获取数组类型，但是调用此方法的时候有个限制，类名必须使用JVM可以识别的签名形式，就是[L${ComponentType};，注意Class.forName()无法获取原始类型(如int、boolean)的类型

Double[] a=new Double[2];

System.out.println(a.getClass());

System.out.println(double[].class);

Class> aClass = Class.forName("[Ljava.lang.Double;");

System.out.println(aClass);

class [Ljava.lang.Double;

class [D

class [Ljava.lang.Double;

获取数组元素(组件)类型：Class#getComponentType()

枚举

所有枚举都继承自java.lang.Enum

boolean java.lang.Class#isEnum()：判断类型是否枚举类型。

T[] java.lang.Class#getEnumConstants()：获取类型中所有的枚举常量。

boolean java.lang.reflect.Field#isEnumConstant()：判断属性是否枚举类型。

1、枚举类型会变成一个普通Java类，这个Java类会继承java.lang.Enum，并且把自身类型作为泛型参数类型，构造函数中必定包含name(字符串类型String)、ordinal(整型int)参数，因为父类java.lang.Enum的构造要求传入这两个参数。

2、所有的枚举成员属性都变成static final修饰的在第1步中提到的Java类的实例，属性的名称和原来枚举的名字一致，实例在静态代码块中创建。

3、新增了一个static final修饰的第1步中提到的Java类的数组实例，名称为$VALUES，此数组在静态代码块中创建，基于此数组还新增了一个静态方法values()，此方法就是直接返回数组的克隆。

public class EnumerationMain {

enum Color {

RED, BLACK, BLUE

}

public static class ColorHolder {

private Color color = Color.BLACK;

}

public static void main(String[] args) throws Exception {

Class colorClass = Color.class;

System.out.println("Color class is enum:" + colorClass.isEnum());

System.out.println("Color values:" + Arrays.toString(colorClass.getEnumConstants()));

ColorHolder colorHolder = new ColorHolder();

Class holderClass = ColorHolder.class;

Field field = holderClass.getDeclaredField("color");

field.setAccessible(true);

System.out.println("Old color:" + field.get(colorHolder));

field.set(colorHolder, Color.RED);

System.out.println("New color:" + field.get(colorHolder));

}

}

Color class is enum:true

Color values:[RED, BLACK, BLUE]

Old color:BLACK

New color:RED

通过反射使用数组有时会比较棘手。特别是需要获得一个特定类型数组的Class对象，如int[]等。本文将讨论如何通过反射创建数组和获得他们的Class对象。

注意：本文在阅读Eyal Lupu的博客"Two Side Notes About Arrays and Reflection"后已更新，他的博客是本文第一个版本的评论。当前版本考虑了他的评论内容。

java.lang.reflect.Array

数组反射是通过类java.lang.reflect.Array实现的。不要把这个类与集合包的java.util.Arrays混淆，java.util.Arrays包含数组排序、转换成集合等。

Creating Arrays

通过反射创建数组是java.lang.reflect.Array实现的。示例代码如下：

int[] intArray = (int[]) Array.newInstance(int.class, 3);

示例代码创建了一个int数组。Array.newInstance()方法的第一个参数int.class定义了数组每一个元素的类型。第二个参数定义数组的元素个数。

Accessing Arrays

可以通过反射访问数组元素。这是通过Array.get(...)和Array.set(...)方法实现的。示例：

int[] intArray = (int[]) Array.newInstance(int.class, 3);

Array.set(intArray, 0, 123);

Array.set(intArray, 1, 456);

Array.set(intArray, 2, 789);

System.out.println("intArray[0] = " + Array.get(intArray, 0));

System.out.println("intArray[1] = " + Array.get(intArray, 1));

System.out.println("intArray[2] = " + Array.get(intArray, 2));

示例代码将输出：

intArray[0] = 123

intArray[1] = 456

intArray[2] = 789

Obtaining the Class Object of an Array

在实现Butterfly DI Container的脚本语言时一个问题就是如何通过反射获得数组的Class对象。无反射代码如下：

Class stringArrayClass = String[].class;

做这些使用Class.forName()并不是直接了当。例如，访问原始int数组类对象代码：

Class intArray = Class.forName("[I");

JVM使用小写l代表int。左边的[的意思是它是我有兴趣的int数组的类对象。其他基本类型也是按照这个模式工作。

对于其他类型对象，需要使用稍微不同的符号：

Class stringArrayClass = Class.forName("[Ljava.lang.String;");

注意：[L在类名的左侧，;在类名的右侧。这段代码的意思是给定类型的数组对象。

作为旁注，你不能使用Class.forName()获得基本类型的类对象。下面的两行代码都会抛出ClassNotFoundException：

Class intClass1 = Class.forName("I");

Class intClass2 = Class.forName("int");

我通常使用像下面的代码获得基本类型的类对象：

public Class getClass(String className){

if("int" .equals(className)) return int .class;

if("long".equals(className)) return long.class;

...

return Class.forName(className);

}

一旦你获得一个类型的Class对象，很简单就能获得这个类型的数组的Class对象。这个解决方案，或者叫它解决办法，是创建指定类型的空数组并通过空数组获得Class对象。这并不很优雅，但是有效。代码如下：

Class theClass = getClass(theClassName);

Class stringArrayClass = Array.newInstance(theClass, 0).getClass();

这提供了一种单一的、统一的方法来访问任何类型的数组的数组类。不要摆弄类名等。

为了确保Class对象确实是一个数组，可以调用Class.isArray()方法来检查：

Class stringArrayClass = Array.newInstance(String.class, 0).getClass();

System.out.println("is array: " + stringArrayClass.isArray());

Obtaining the Component Type of an Array

一旦你获得数组的Class对象，你可以通过Class.getComponentType()访问它的组合类型。组合类型是数组中的元素的类型。例如，int[]数组的组合类型是int.class的Class对象。String[]数组的组合类型是java.lang.String的Class对象。

访问数组的组合类型的代码如下：

String[] strings = new String[3];

Class stringArrayClass = strings.getClass();

Class stringArrayComponentType = stringArrayClass.getComponentType();

System.out.println(stringArrayComponentType);

示例代码将输出"java.lang.String"，这是String[]数组的组合类型。