Java中的反射库（reflection library）中提供了一个非常丰富且精心设计的工具集，以便编写能够动态...

版权声明：此文章转载自CSDN。 

如需转载请联系听云College团队成员阮小乙，邮箱：ruanqy#tingyun.com

Java中的反射库（reflection library）中提供了一个非常丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序。

能够分析类能力的程序称为反射（reflective）。反射的功能很强大，下面是反射的用途：

• 在运行中分析类的能力；

• 在运行中查看对象，例如编写一个toString方法供所有类使用；

• 实现通用的数组操作代码；

• 利用Method对象，这个对象很像C++中的函数指针；

1 Class类的使用

Java是面向对象的语言，在Java中，所有的东西都是类（除了静态方法和基本类型）。那么，类是不是一个对象呢？

在Java程序运行期间，Java运行时系统时钟为所有的对象维护一个被称为运行时的类型标志。这个信息跟踪着每个对象的所属类。虚拟机利用运行时类型信息选择相应的方法执行。

Class类保存了Java类的这些信息。官网中，对这个类型称为类的类类型，也就是说一个类的对象。比如，有一个类Student，可以使用下面的代码创建一个实例：

Stuent stu=new Studnet();

即stu是类Student的一个实例。那既然类也是对象，那么Student是什么的实例呢？Student是类Class的一个实例。

可以通过如下三种方法获得一个类的类类型。

（1）getClass方法

如果有一个类的实例，那么可以通过这个实例的getClass方法获得这个类的类类型：

Class cl=stu.getClass();

（2）静态方法forName

forName是Class的一个静态方法，如果没有一个类的实例，但是知道这个类的名字，可以使用这个方法获得这个类的类类型：

Class cl=Class.forName("Student");

如果类名保存在字符串中，并可在运行中改变，就可以使用这个方法。当然，这个方法只有在参数是类名或接口名的时候才能够执行，否则forName方法将抛出一个异常。因此，使用这个方法时，应该处理这个异常。

（3）.class

第三个获得类类型 的方法很简单。如果T是任意的Java类型，T.class将代表匹配的类对象。比如：

Class cl1=Student.class;   Class cl2=int.class   Class cl3=Double[].class

注意，一个Class对象实际上表示一个类型，而这个类型不一定是一个类。比如，int不是类，但int.class是一个Class类型的对象。

虚拟机为每个类型管理一个Class对象。因此可以使用==运算符实现两个类对象的比较：

if(stu.getClass()==Student.class)...

这将判断为真。

Class中最常用的一个方法就是getName方法，这个方法将返回类的名字。

还可以通过类类型创建一个类的实例。比如：

Class cl=Student.class;   Student stu=(Student)cl.newInstance();

这就创建了一个Student实例。不过，newInstance方法使用的是默认的构造器（没有参数的构造器）初始化新创建的对象。

使用forName和newInstance方法可以根据存储在字符串中的类名创建一个实例：

String s="java.util.Date";   Object date=Class.forName(s).newInstance();

2 捕获异常

在第一节中，Class类的forName方法可能会抛出一个异常，可以使用下面的代码捕获并处理异常：

try{       String name=...;//get class name       Class cl=Class.forName(name);//might throw exception       do something with cl   }catch(Exception e){       e.printStackTrace();   }

3 利用反射分析类的能力

下面简要的介绍一下反射机制最重要的内容：检查类的结构。

在java.lang.reflect包中有三个类Field、Method和Constructor分别描述类的域、方法和构造器。这三个类都有一个叫getName的方法，用来返回项目的名称。Field类有一个getType方法，用来返回描述域所属的Class对象。Method和Constructor类有能够报告参数类型的方法，Method还有一个可以报告返回类型的方法。这三个类有一个getModifiers的方法，它将返回一个整数值，用不同的位开关描述public和static这样的修饰符的使用状况，还可以利用Modifier.toString方法将修饰符打印出来。

Class类的getFields、getMethods和getCostructors方法可以获得类提供的public域、方法和构造器数组，其中包括超类的共有成员。Class类的getDeclatedFields、getDeclatedMethods和getDeclaredConstructors方法可以获得类中声明的全部域、方法和构造器，其中包括私有和受保护的成员，但不包括超类的成员。

Constructor类：

• String getName()：返回构造器的名字；

• int getModifiers()：返回修饰符；

• int getParameterCount()：返回构造器中参数的个数；

• Class<?>[] getParameterTypes()：返回参数的类型；

Field类：

• String getName()：返回域的名字；

• int getmodifiers()：返回修饰符；

• Class<?> getType()：返回域的类类型；

Method类：

• String getName()：返回方法的名字；

• int getModifiers()：返回修饰符；

• int getParameterCount()：返回参数的个数；

• Class<?>[] getParameterTypes()：返回参数的类类型；

• Class<?> getReturnType()：返回返回类类型；

下面的代码编写了一个可以打印一个类的所有构造器、方法和域的相关信息的类：

package reflection;   import java.lang.reflect.*;   public class PrintClassInfo {       private PrintClassInfo(){}       public static void printClassInfo(String name){           try{               Class cl=Class.forName(name);               Class supercl=cl.getSuperclass();               String modifiers=Modifier.toString(cl.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print("class "+name);               if(supercl!=null&&supercl!=Object.class)System.out.print(" extends "+supercl.getName());               System.out.print("/n{/nConstructors:/n");               printConstructors(cl);               System.out.println("Methods:");               printMethods(cl);               System.out.println("Fields:");               printFields(cl);               System.out.println("}");                }catch(ClassNotFoundException e){               e.printStackTrace();           }           System.exit(0);       }       public static void printConstructors(Class cl){           Constructor[] cons=cl.getConstructors();           for(Constructor c:cons){               String name=c.getName();               System.out.print("    ");               String modifiers=Modifier.toString(c.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print(name+"(");                              Class[] paramTypes=c.getParameterTypes();               for(int i=0;i<paramTypes.length;i++)               {                   if(i>0)System.out.print(", ");                   System.out.print(paramTypes[i].getName());               }               System.out.println(");");           }                    }       public static void printMethods(Class cl){           Method[] methods=cl.getDeclaredMethods();           for(Method m:methods){               Class retType=m.getReturnType();               String name=m.getName();               System.out.print("    ");               String modifiers=Modifier.toString(m.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print(retType.getName()+" "+name+"(");                              Class[] paramTypes=m.getParameterTypes();               for(int i=0;i<paramTypes.length;i++){                   if(i>0)System.out.print(", ");                   System.out.print(paramTypes[i].getName());               }               System.out.println(");");           }       }        public static void printFields(Class cl){           Field[] fields=cl.getDeclaredFields();           for(Field f:fields){               Class type=f.getType();               String name=f.getName();               System.out.print("    ");               String modifiers=Modifier.toString(f.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.println(type.getName()+" "+name+";");           }       }   }

这个类有一个静态方法printClassInfo，用于打印类的基本信息，在方法的内部调用了printConstructors、printMethosds和printFields方法。测试代码如下：

String name;   System.out.println("Enter the class name:");   Scanner scanner=new Scanner(System.in);   name=scanner.next();   PrintClassInfo.printClassInfo(name);

运行输入java.lang.String，结果如下：

public final class java.lang.String { Constructors:     public java.lang.String([B, int, int);     public java.lang.String([B, java.nio.charset.Charset);     public java.lang.String([B, java.lang.String);     public java.lang.String([B, int, int, java.nio.charset.Charset);     public java.lang.String([B, int, int, java.lang.String);     public java.lang.String(java.lang.StringBuilder);     public java.lang.String(java.lang.StringBuffer);     public java.lang.String([B);     public java.lang.String([I, int, int);     public java.lang.String();     public java.lang.String([C);     public java.lang.String(java.lang.String);     public java.lang.String([C, int, int);      public java.lang.String([B, int);     public java.lang.String([B, int, int, int); Methods:     public boolean equals(java.lang.Object);     public java.lang.String toString();     public int hashCode();     public int compareTo(java.lang.String);     public volatile int compareTo(java.lang.Object);     public int indexOf(java.lang.String, int);     public int indexOf(java.lang.String);     public int indexOf(int, int);     public int indexOf(int);     static int indexOf([C, int, int, [C, int, int, int);     static int indexOf([C, int, int, java.lang.String, int);     public static java.lang.String valueOf(int);     public static java.lang.String valueOf(long);     public static java.lang.String valueOf(float);     public static java.lang.String valueOf(boolean);     public static java.lang.String valueOf([C);     public static java.lang.String valueOf([C, int, int);     public static java.lang.String valueOf(java.lang.Object);     public static java.lang.String valueOf(char);     public static java.lang.String valueOf(double);     public char charAt(int);         private static void checkBounds([B, int, int);     public int codePointAt(int);     public int codePointBefore(int);     public int codePointCount(int, int);     public int compareToIgnoreCase(java.lang.String);     public java.lang.String concat(java.lang.String);     public boolean contains(java.lang.CharSequence);     public boolean contentEquals(java.lang.CharSequence);     public boolean contentEquals(java.lang.StringBuffer);     public static java.lang.String copyValueOf([C);     public static java.lang.String copyValueOf([C, int, int);     public boolean endsWith(java.lang.String);     public boolean equalsIgnoreCase(java.lang.String);     public static transient java.lang.String format(java.util.Locale, java.lang.String, [Ljava.lang.Object;);     public static transient java.lang.String format(java.lang.String, [Ljava.lang.Object;);     public void getBytes(int, int, [B, int);     public [B getBytes(java.nio.charset.Charset);     public [B getBytes(java.lang.String);     public [B getBytes();     public void getChars(int, int, [C, int);     void getChars([C, int);     private int indexOfSupplementary(int, int);     public native java.lang.String intern();     public boolean isEmpty();     public static transient java.lang.String join(java.lang.CharSequence, [Ljava.lang.CharSequence;);     public static java.lang.String join(java.lang.CharSequence, java.lang.Iterable);     public int lastIndexOf(int);     public int lastIndexOf(java.lang.String);     static int lastIndexOf([C, int, int, java.lang.String, int);     public int lastIndexOf(java.lang.String, int);     public int lastIndexOf(int, int);     static int lastIndexOf([C, int, int, [C, int, int, int);     private int lastIndexOfSupplementary(int, int);     public int length();     public boolean matches(java.lang.String);     private boolean nonSyncContentEquals(java.lang.AbstractStringBuilder);     public int offsetByCodePoints(int, int);     public boolean regionMatches(int, java.lang.String, int, int);     public boolean regionMatches(boolean, int, java.lang.String, int, int);     public java.lang.String replace(char, char);     public java.lang.String replace(java.lang.CharSequence, java.lang.CharSequence);     public java.lang.String replaceAll(java.lang.String, java.lang.String);     public java.lang.String replaceFirst(java.lang.String, java.lang.String);     public [Ljava.lang.String; split(java.lang.String);     public [Ljava.lang.String; split(java.lang.String, int);     public boolean startsWith(java.lang.String, int);     public boolean startsWith(java.lang.String);     public java.lang.CharSequence subSequence(int, int);     public java.lang.String substring(int);     public java.lang.String substring(int, int);     public [C toCharArray();     public java.lang.String toLowerCase(java.util.Locale);     public java.lang.String toLowerCase();     public java.lang.String toUpperCase();     public java.lang.String toUpperCase(java.util.Locale);     public java.lang.String trim(); Fields:     private final [C value;     private int hash;     private static final long seria   lVersionUID;     private static final [Ljava.io.ObjectStreamField; serialPersistentFields;     public static final java.util.Comparator CASE_INSENSITIVE_ORDER; }

值得注意的是，这个程序可以分析Java解释器能够加载的任何类，而不仅仅是编译程序时可以使用的类。

4 动态加载类

类的加载有两种方式，一个是在编译时加载的静态加载类，另一个是在运行时加载的动态加载类。当我们使用new来创建一个对象时，使用的是静态加载类，这个时候必须保证类已经实现。而Class的forName方法不但可以获得一个类的类类型，还是一个动态加载类的方法，可以越过编译，在运行时加载一个类。

动态加载有什么好处么？考虑一个场景，比如自己要实现一个办公软件Office，里面有各种组件Word和Excel等。有一个Office工具可以启动各种组件，由于现阶段只有两个组件Word和Excel，那么Office可以这样编写：

class Office   {       public static void main(String[] args)       {           if("Word".equals(args[0]))           {               Word w=new Word();               w.start();           }           if("Excel".equals(args[0]))           {               Excel e=new Excel();               e.start();           }       }   }

这里，根据传进来的参数选择启动哪一个组件。

这里使用的就是静态加载，因为使用new创建的一个对象。不过，如果开发Word的组工作较快，已经完成了开发，代码假如如下：

class Word   {       public void start()       {           System.out.println("Word running...");       }   }

这仅仅打印一句话，但是Excel组开发较慢，还没有开发出来，那么Office还能用么？当然不能，编译Office出错：

说找不到Excel类。这样，整个的Office都不能使用了。

这时，就可以使用动态加载了。使用Class的forName方法动态加载一个类：

Word w=(Word)Class.forName(args[0]);

不过这里有个问题，就是由于没能事先知道首先实现的是哪个组件，所以不能强制类型转换成Word。那怎么办？就可以使用接口了。定义一个接口OfficeAble，让所有的组件实现这个接口即可：

interface OfficeAble   {       void start();   }

新的Word类如下：

class Word implements OfficeAble   {       public void start()       {           System.out.println("Word running...");       }   }

这样，在OfficeBetter类中就可以使用接口了：

class OfficeBetter   {       public static void main(String[] args)       {           try           {               Class cl=Class.forName(args[0]);               OfficeAble oa=(OfficeAble)cl.newInstance();               oa.start();           }           catch(Exception e)           {               e.printStackTrace();           }       }   }

注意，forName会抛出异常，要进行捕获并处理。

这时，编译Word和OfficeBetter：

编译没有错误了，运行也正确。

当启动Excel时就会报错：

说没有找到Excel类。

当Excel实现完后，只需要编译Excel，不需要编译OfficeBetter就可以运行：

结果正确。这样，使用动态加载类，就可以随时添加功能而不需要重新编译。

5 在运行时使用反射分析对象

现在已经知道了如何查看任意对象的数据域名称和类型：

（1）获得对应的类类型；

（2）通过类类型调用getDeclaredFields方法；

利用反射机制可以查看在编译时还不清楚的对象域。

查看对象域的关键方法是Field类中的get方法。如果f是一个Field类型的对象，obj是某个包含f域的类的对象，f.get(obj)将返回一个对象，其值为obj与的当前值。

既然能够得到域的值，那么也就能设置域的值。可以使用Field类中的set方法设置域的值，用法为f.set(obj,value)，obj是包含f域的对象，value是要设置的值。

还要注意，如果f是一个私有域，那么直接使用get方法会抛出一个IllegalAccessException异常。除非拥有访问权限，否则Java安全机制只允许查看任意对象有哪些域而不允许得去域的值。

反射机制的默认行为受限于Java的访问控制。然而，如果一个Java程序没有受到安全管理器的控制，就可以覆盖访问控制。可以调用Field、Method或Constructor类中的setAccessible方法达到这个目的：

f.setAccessible(true);

setAccessible方法是AccessibleObject类中的一个方法，它是Field、Method和Constructor类的超类。

下面的代码演示了使用get和set方法获得和设置域的值：

Student stu=new Student("Bai",20,99);   Class cl=stu.getClass();   Field f=cl.getDeclaredField("name");   f.setAccessible(true);   String stuname=(String)f.get(stu);   System.out.println("The name is:"+stuname);   f.set(stu, "Liu");   System.out.println("The name is:"+(String)f.get(stu));

其中Student类包含String类型的name、int类型的age和double类型的score。

运行结果如下：

The name is:Bai The name is:Liu

即成功获得和设置域的值。

不过get还有一个问题，就是name是一个String，因此把它当做Object返回没有问题。但是如果要返回double的score，double不是对象，这时可以使用Field类中的getDouble方法。此时，反射机制会自动将这个域值打包到相应的对象包装器中。

Field fs=cl.getDeclaredField("score");   fs.setAccessible(true);   System.out.println("The score is:"+fs.getDouble(stu));

结果如下：

The score is:99.0

6 使用invoke调用任意方法

在C和C++中，可以从函数指针执行任意函数。虽然Java没有提供函数指针，但反射机制允许调用任意方法。

和Field中的get方法类似，Method类中有个invoke方法，它允许调用包装在当前Method对象中的方法。invoke方法的签名是：

Object invoke(Object obj,Object... args);

从这里可以看出，invoke方法有个Object类型的返回值，不过，要是调用的方法没有返回值呢，这时invoke放回null。还有，invoke第一个参数是一个对象，第二个参数是一个可变参数，实际上就是一个Object数组。

在一个类中，必须知道哪些信息才能唯一确定一个方法呢？

由于Java中可以有同名的方法，因此可以使用参数来进行区分。不过要注意，返回类型不能作为区分两个函数的依据。因此，在使用Method类中的getMethod和getDeclaredMethod方法时，要给出方法名和方法参数：

Method getMethod(String name,Class... parameterTypes)

下面的例子给出了invoke的使用：

import java.lang.reflect.*;   public class InvokeTest {       public static void main(String[] args) {           A a=new A();           Class cl=a.getClass();           try {               Method m1=cl.getMethod("add", new Class[]{String.class,String.class});               m1.invoke(a, new Object[]{"hello","world"});               Method m2=cl.getMethod("add", int.class,int.class);               m2.invoke(a, 1,2);               Method m3=cl.getMethod("add");               m3.invoke(a);               Method m4=cl.getMethod("add", String.class,int.class);               m4.invoke(null, "Liu",100);           } catch (Exception e) {               // TODO Auto-generated catch block               e.printStackTrace();           }       }   }   class A{       public void add(){           System.out.println("do nothing...");       }       public void add(int a,int b){           System.out.println(a+b);       }       public void add(String a,String b){           System.out.println(a.toUpperCase()+b.toUpperCase());       }       public static void add(String name,int age){           System.out.println(name+" is "+age+" years old.");       }   }

这里定义了一个简单的类A，里面有四个方法名相同的方法add，其中一个是静态方法。这四个方法的返回类型都是void，因此可以通过参数类型进行区分。在测试代码中我们使用getMethod方法获得add方法，其中第一个参数都是add，第二个参数给出参数类型。第二个参数是一个可变参数，即 一个数组，有两种方法给出这个可变参数。

第一种，构造一个Class数组：

Method m1=cl.getMethod("add", new Class[]{String.class,String.class});

还可以直接列出参数，有几个就列出几个，用逗号（,）分隔：

Method m2=cl.getMethod("add", int.class,int.class);

获得Method对象后，就可以调用invoke执行这个方法了。invoke有两个参数，第一个参数给出包含这个方法的对象，第二个参数也是一个可变参数，即传递给要执行的方法的参数。对给出参数可以使用上面两种方法中的一种。

这里要注意的是，对于静态方法，没有包含它的对象，这时第一个参数置为null即可。

运行结果如下：

HELLOWORLD 3 do nothing... Liu is 100 years old.

7 反射与泛型

我们知道，集合中的泛型使得一个集合中只能保存一种类型数据。比如ArrayList<String>只能保存String类型，如果代码中有add(20)就会报错，因为20是int类型，不能转换成String。那么泛型是在哪个阶段起作用呢？

泛型的使用在编写代码中起到了一种类型检查的作用。我们知道，泛型只是编译器的功能，Java虚拟机并没有泛型，也就是说，是不是如果绕过编译，就能在泛型中添加别的类型的数据呢？比如在ArrayList<String>中添加int数据。

下面的代码演示了这种情况：

import java.lang.reflect.*;   import java.util.ArrayList;   public class MethodDemo {       public static void main(String[] args) {           ArrayList list=new ArrayList();           ArrayList<String> list1=new ArrayList<>();                   System.out.println(list.getClass()==list1.getClass());       }   }

上面的代码定义了两个ArrayList，其中list不是泛型，list1是泛型。我们首先检查list和list的类类型是否相同。结果如下：

true

说明在编译阶段是去泛型化的。

接下来修改代码如下：

import java.lang.reflect.*;   import java.util.ArrayList;   public class MethodDemo {       public static void main(String[] args) {           ArrayList list=new ArrayList();           ArrayList<String> list1=new ArrayList<>();                      list.add(10);           list.add("hello");                      list1.add("world");           //list1.add(20);ERROR:can't add int to ArrayList<String>                                 try {           Method m=list1.getClass().getDeclaredMethod("add", Object.class);               m.invoke(list1, 20);               System.out.println(list1.size());               System.out.println(list1);               for(String s:list1){                   System.out.print(s+" ");               }           } catch (Exception e) {               // TODO: handle exception               e.printStackTrace();           }       }   }

直接在list1中使用add添加一个int数据不能成功，编译器会报错。之后使用Method中的getDeclaredMethod方法获得ArrayList<String>中的add方法，然后使用invoke调用这个方法添加一个int数据。这时，编译器没有报错。打印list1的长度和内容，检查是否添加成功。最后使用for循环遍历list1中的内容。结果如下：

长度为2，内容也正确，说明我们跳过了编译阶段的类型检查，在运行时成功添加了int类型数据。不过，使用for循环遍历是报错了，因为20不是String类型数据。

通过这个例子，可以知道，泛型会在编译时去泛型化。同时可以通过反射在运行阶段添加数据。

8 使用java.lang.reflect包中的Array类编写泛型数组

java.lang.reflect包中的Array类可以动态创建数组。比如，可以将这个特性应用到Array类的copyOf方法实现中。

如果要给一个Student[]数组复制，可以先将Student[]转换为Object[]数组，比如这样：

public static Object[] badCopyOf(Object[] a,int newLength){       Object[] newArray=new Object[newLength];       System.arraycopy(a, 0, newArray, 0, Math.min(a.length, newLength));       return newArray;   }

不过，这样的话，返回的类型是Object[]，而Object[]不能转化为Student[]类型。

为了编写通用的方法，需要创建一个与原数组类型相同的新数组。为此，需要java.lang.reflect包中的Array类中的一些方法。

Array类中有一个newInstance方法，能够创建新数组。这个方法要两个参数，一个是数组的元素类型，另一个是数组的长度：

Object newArray=Array.newInstance(componentType,newLength);

这样，就需要获得数组元素的类型和数组的长度。使用Array类中的getComponentType方法可以获得元素的类型，使用Array类中的getLength方法可以获得数组的长度。

下面是完整的代码：

import java.lang.reflect.*;   import java.util.Arrays;   public class CopyOfTest {       public static void main(String[] args) {           int[] a={1,2,3};           a=(int[])goodCopyOf(a,10);           System.out.println(Arrays.toString(a));                      String[] b={"Tom","Dick","Harry"};           b=(String[])goodCopyOf(b,10);           System.out.println(Arrays.toString(b));                      b=(String[])badCopyOf(b,10);       }       public static Object[] badCopyOf(Object[] a,int newLength){           Object[] newArray=new Object[newLength];           System.arraycopy(a, 0, newArray, 0, Math.min(a.length, newLength));           return newArray;       }        public static Object goodCopyOf(Object a,int newLength){           Class cl=a.getClass();           if(!cl.isArray())return null;           Class componentType=cl.getComponentType();           int length=Array.getLength(a);           Object newArray=Array.newInstance(componentType, newLength);           System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength));           return newArray;       }   }

结果如下：

注意，应该将goodCopyOf的参数声明为Object类型，而不要声明成Object[]。因为正数数组类型int[]可以转换成Object，但不能转换成对象数组。

想阅读更多技术文章，请访问听云技术博客，访问听云官方网站感受更多应用性能优化魔力。