第12章 反射
12.1 反射概述
Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以得到任意一个对象所属的类的信息，可以调用任意一个类的成员变量和方法，可以获取任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。
反射机制的优点是可以实现动态创建对象和编译(即动态编译)，特别是在J2EE的开发中，反射的灵活性表现的十分明显。例如，一个大型的软件，不可能一次就把程序设计的很完美，当这个程序编译、发布上线后，如果需要更新某些功能，我们不可能要用户把以前的软件卸载，再重新安装新的版本。这时，如果采用静态编译，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制，程序可以在运行时动态的创建和编译对象，不需要用户重新安装软件，即可实现功能的更新。
12.2 认识Class类
Java程序的运行机制，JVM编译.java文件生成对应的.class文件，然后再将.class文件加载到内存中执行。在执行.class文件的时候可能需要用到其他类（其他.class文件内容），这个时候就需要获取其他类的信息（反射）。JVM在加载.class文件时，会产生一个java.lang.Class对象代表该.class字节码文件，从该Class对象中可以获得类的信息。因此要想完成反射操作，就必须先认识Class类。
Class是JDK定义的类，它提供了很多方法，通过调用Class类的成员方法可以获取Class对象中的信息（.class文件中的类信息）。Class类的常用方法如下表。
| 方法 | 描述 |
|---|---|
| public static Class forName(String className) throws ClassNotFoundException | 传入完整的“包.类”名称实例化Class对象 |
| public Constructor[] getConstructors() throws SecurityException | 得到一个类中的全部构造方法 |
| public Field[] getDeclaredFields() throws SecurityException | 得到本类中单独定义的全部属性 |
| public Field[] getFields() throws SecurityException | 取得本类继承而来的全部属性 |
| 方法 | 描述 |
|---|---|
| public Method[] getMethods() throws SecurityException | 得到一个类中的全部方法 |
| public Method getMethod(String name,Class...parameter Type)throws NoSuchMethodException,SecurityException | 返回一个Method对象，并设置一个方法中的所有参数类型 |
| public Class[] getInterfaces() | 得到一个类中所实现的全部接口 |
| public String getName() | 得到一个类完整的“包.类”名称 |
| public Package getPackage() | 得到一个类的包 |
| public Class getSuperclass() | 得到一个类的父类 |
| public Object newInstance() throws InstantiationException,IllegalAccessException | 根据Class定义的类实例化对象 |
| public Class getComponentType() | 返回表示数组类型的Class |
| public boolean isArray() | 判断此Class是否是一个数组 |
由于Class对象代表的是.class文件（类），因此可以说所有的类实际上都是Class类的实例，所有的对象都可以转变为Class类型表示。
实例化Class对象共有以下三种方式：
（1）根据类名获取：类名.class；
（2）根据对象获取：对象.getClass()；
（3）根据全限定类名获取：Class.forName(“全限定类名”)。
Class类本身没有定义任何的构造方法，所以如果要使用Class类，必须通过上述三种方式进行实例化。接下来，通过一个案例演示Class类的上述三种实例化方式。
class A{
}
class Example01 {
public static void main(String args[]){
Class c1 = null;
Class c2 = null;
Class c3 = null;
try{
c1 = Class.forName("cn.itcast.A");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
c2 = new A().getClass();
c3 = A.class;
System.out.println("类名称："+c1.getName());
System.out.println("类名称："+c2.getName());
System.out.println("类名称："+c3.getName());
}
}
上述代码中，第9行代码使用forName()方法实例化Class对象c1，第13行代码使用对象.getClass()的方式实例化Class对象c2，第14行代码使用类名.class的方式实例化Class对象c3。从图12-3的运行结果可以发现，3种实例化Class对象的结果是一样的，但是使用forName()方法实例化Class对象只需要将类的全限定类名以字符串作为参数传入即可，这让程序具备了更大的灵活性，所以使用forName()方法实例化Class对象是较为常用的一种方式，读者应重点掌握。
12.3 Class类的使用
了解了Class类的实例化过程，那么到底该如何去使用Class类呢？实际上Class在开发中最常见的用法就是将Class类对象实例化为自定义类对象，即可以通过一个给定的字符串（类的全限定类名）实例化一个本类的对象。将Class对象实例化为本类对象时，可以通过无参构造完成，也可以通过有参构造完成。
12.3.1 通过无参构造函数实例化对象
如果想通过Class类实例化其他类的对象，则可以使用newInstance()方法，但是必须要保证被实例化的类中存在一个无参构造方法。接下来通过一个案例演示Class类通过无参构造实例化对象。
class Person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
class Example02 {
public static void main(String args[]){
Class c = null;
try{
c = Class.forName("cn.itcast.Person");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Person per = null;
try{
per = (Person)c.newInstance();
}catch (Exception e){
e.printStackTrace();
}
per.setName("张三");
per.setAge(30);
System.out.println(per);
}
}
上述代码中，第1~19行代码创建了一个Person类，在Person类中定义了name和age属性。第24行代码是通过Class.forName()方法实例化Class对象，第30行代码是使用Class对象c调用newInstance()方法并传入的完整“包.类”名称，对Person对象进行实例化操作。
在使用newInstance()方法实例化类对象时，被实例化对象的类中必须存在无参构造方法，否则无法实例化对象。
接下来演示没有无参构造方法时，通过newInstance()方法实例化对象。
class Person{
private String name;
private int age;
public Person(String name,int age){ //定义有参构造方法
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
class Example03 {
public static void main(String args[]){
Class c = null;
try{
c = Class.forName("cn.itcast.Person");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Person per = null;
try{
per = (Person)c.newInstance();
}catch (Exception e){
e.printStackTrace();
}
}
}
因为Person类中并没有存在无参构造方法，所以第35行代码对Person对象进行实例化时，无法直接使用newInstance()方法实例化的。由运行结果可知，报错信息提示Person类中没有发现无参构造方法，无法使用newInstance()方法实例化Person对象。因此，在使用Class类实例化对象时一定要在类中编写无参构造方法。
12.3.2 通过有参构造实例化对象
如果类中没有无参构造方法，则可以通过有参构造方法实例化对象。通过有参构造方法实例化对象时，需要明确调用的构造方法，并传递相应的参数。通过有参构造方法实例化对象的操作步骤如下：
（1）通过Class类中的getConstructors()方法获取本类中的全部构造方法。
（2） 向构造方法中传递一个对象数组，对象数组里面包含构造方法中所需的各个参数。
（3）通过Constructor类实例化对象。
上述操作步骤中使用了Constructor类，Constructor类用于存储本类的构造方法。Constructor类的常用方法如下表。
| 方法 | 描述 |
|---|---|
| publicint getModifiers() | 得到构造方法的修饰符 |
| public String getName() | 得到构造方法的名称 |
| public Class[] getParameterTypes() | 得到构造方法中参数的类型 |
| public String toString() | 返回此构造方法的信息 |
| public T newInstance(Object...initargs) throws InstantistionException, IllegalAccessException,IllegalArgumentException, InvocationTargetException | 向构造方法中传递参数，实例化对象 |
import java.lang.reflect.Constructor;
class Person{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
class Example04 {
public static void main(String args[]){
Class c = null;
try{
c = Class.forName("cn.itcast.Person");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Person per = null;
Constructor cons[] = null;
cons = c.getConstructors();
try{
per = (Person)cons[0].newInstance("张三"，30);
}catch (Exception e){
e.printStackTrace();
}
System.out.println(per);
}
}
上述代码中，第5~8行代码定义了Person类的有参构造方法。第34~35行代码通过Class类取得了Person类中全部构造方法，并以对象数组的形式返回。第27行代码调用了Person类中的构造方法，而在Person类中只有一个构造方法，所以直接取出对象数组中的第一个元素即可（下表为0就表示调用第一个构造方法）。在声明对象数组时，必须考虑到构造方法中参数的类型顺序，所以第一个参数的类型为String，第二个参数的类型为Integer。
12.4 反射的作用
在实际开发中，通过反射可以得到一个类的完整结构，包括类的构造方法、类的属性、类的方法，这就需要使用到java.lang.reflect包中的以下几个类：
（1）Constructor：表示类中的构造方法。
（2）Field：表示类中的属性。
（3）Method：表示类中的方法。
Constructor、Field、Method都是AccessibleObject类的子类。
12.4.1 获取所实现的全部接口
要取得一个类所实现的全部接口，必须使用Class中的getInterfaces()方法。getInterfaces()方法声明如下：
public Class[] getInterfaces();
getInterfaces()方法返回一个Class类的对象数组，调用Class类中的getName()方法可以取得类的名称。
接下来通过一个案例讲解通过getInterfaces()方法获取一个类所实现的全部接口。
interface China{
public static final String NATION = "CHINA";
public static final String AUTHOR = "张三";
}
class Person implements China{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
public class Example05 {
public static void main(String args[]){
Class c = null;
try{
c = Class.forName("cn.itcast.Person");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Class cons[] = c.getInterfaces();
for (int i = 0;i < cons.length; i++){
System.out.println("实现的接口名称："+ cons[i].getName());
}
}
}
上述代码中，第1~4行代码定义了一个China接口，第5~27行代码定义了一个Person类并实现了China接口。因为接口是类的特殊形式，而且一个类可以实现多个接口，所以，第36~39行代码以Class数组的形式将全部的接口对象返回，并利用循环的方式将内容依次输出。由图12-6可知，Person类实现了China接口。
12.4.2 获取全部方法
要取得一个类中的全部方法，可以使用Class类中的getMethods()方法，该方法返回一个Method类的对象数组。如果想要进一步取得方法的具体信息，如方法的参数、抛出的异常声明等，就必须依靠Method类。
Method类的常用方法如下表。
| 方法 | 描述 |
|---|---|
| public int getModifiers() | 得到本方法的修饰符 |
| public String getName() | 得到方法的名称 |
| public Class[] getParameterTypes() | 得到方法的全部参数的类型 |
| public Class getReturnType() | 得到方法的返回值类型 |
| public Class[] getExceptionType() | 得到一个方法的全部抛出异常 |
| public T newInstance(Object...initargs) throws InstantistionException, IllegalAccessException,IllegalArgumentException, InvocationTargetException | 通过反射调用类中的方法 |
interface China{
public static final String NATION = "CHINA";
public static final String AUTHOR = "张三";
public void sayChina();
}
class Person{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
class Example06{
public static void main(String args[]){
Class c = null;
try{
c = Class.forName("cn.itcast.Person");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
Class cons[] = c.getInterfaces();
for (int i = 0;i < cons.length; i++){
System.out.println("实现的接口名称："+ cons[i].getName());
}
}
}
上述代码中，第1~5行代码首先定义了一个China接口，并在China接口中定义了两个final修饰的String属性和sayChina()方法。第6~28行代码定义了一个Person类。最后在30~41行的main()方法中定义了一个Class的对象，通过Class对象调用forName()方法获取了“cn.itcast.Person”的所有方法。并定义了一个名称为cons[]的Class集合，用于存储Class的所有接口，最后使用for循还打印consp[]集合。
从运行结果可以发现，程序不仅将Person类的方法输出，也把从Object类中继承而来的方法同样进行了输出。
12.4.3 获取全部属性
在反射操作中也可以获取一个类中的全部属性，但是类中的属性包括两部分，从父类继承的属性，本类定义的属性。因此，在获取类的属性时也有两种不同的方式，分别如下：
（1）获取实现的接口或父类中的公共属性：public Field[] getFields throws SecurityException。
（2）获取本类中的全部属性：public Field[] getDeclaredFields throws SecurityException。
上述两种方法返回的都是Field数组，每一个Field对象表示类中的一个属性。如果要获取属性的详细信息，就需要调用Field类的方法。Field类的常用方法如下表。
| 方法 | 描述 |
|---|---|
| public int getModifiers() | 得到本方法的修饰符 |
| public String getName() | 得到方法的名称 |
| public boolean isAccessible() | 判断此属性是否可被外部访问 |
| public void setAccessible(Boolean flag)throws SecurityException | 设置一个属性是否可被外部访问 |
| public String toString() | 返回此Filed类的信息 |
| public Object get(Object obj)throws IllegalArgument Exception,IllegalAccessException | 得到一个对象中属性的具体内容 |
| public void set(Object obj, Object value)throws IllegalArgument Exception,IllegalAccessException | 设置指定对象中属性的具体内容 |
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
class Person{
private String name;
private int age;
public Person(String name,int age){
this.setName(name);
this.setAge(age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "姓名："+this.name+",年龄："+this.age;
}
}
public class Example07{
public static void main(String[] args){
Class c1 = null;
try{
c1 = Class.forName("cn.itcast.Person");
}catch (ClassNotFoundException e){
e.printStackTrace();
}
{
Field f[] = c1.getDeclaredFields(); //取得本类属性
for (int i = 0;i r = f[i].getType(); //取得属性的类型
int mo = f[i].getModifiers(); //得到修饰符数字
String priv = Modifier.toString(mo); //取得属性的修饰符
System.out.print("本类属性：");
System.out.print(priv+" "); //输出修饰符
System.out.print(r.getName()+" "); //输出属性类型
System.out.print(f[i].getName()); //输出属性名称
System.out.println(" ;");
}
}
}
}
上述代码中，第3~25行代码定义了一个Person类，并在Person类中定义了name和age属性。第30行代码实例化了一个Class对象c1；第35行代码通过调用Class类的getDeclaredFields()方法获取Person类的所有属性，并存入Filed数组中。第36~45行代码通过for循环输出Filed数组中Person类的属性。
【案例12-1】 重写toString()方法
为了方便输出对象，Object类提供了toString()方法。但是该方法的默认值是由类名和哈希码组成的，实用性并不强。通常需要重写该方法以提供更多的对象信息。
本案例要求使用反射重写类的toString()方法，并通过反射输出类的包名、类名、类的公共构造方法、类的公共域和类的公共方法。
（1）通过任务的描述可知，此程序需要利用反射重写toString()方法，因此，需要先创建一个类，并在该类中定义两个方法，一个是toString()方法，用于输出类的包、类的名字、类的公共构造方法、类的公共域和类的公共方法等信息；另一个是main()方法，用来进行测试。
（2）由于是重写Object类的toString()方法，因此需要给toString()方法传递一个Object对象。
（3）由于需要利用反射输出类的包、类的名字、类的公共构造方法、类的公共域和类的公共方法，故需要先通过Object对象.getClass()获得代表该类的Class对象，再通过类的Class对象. getPackage()获得类所在的包，通过类的Class对象.getSimpleName()获得类的简单名称，通过类的Class对象.getDeclaredConstructors()获得所有代表构造方法的Constructor数组，遍历数组，判断如果是访问控制符为“public”即为公共构造方法。通过类的Class对象.getDeclaredFields()获得代表所有域的Field数组，遍历数组，判断如果是访问控制符为“public”即为公共域。通过类的Class对象.getDeclaredMethods()获得代表所有方法的Method[]数组，遍历数组，判断如果是访问控制符为“public”即为公方法。
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.Field;
3 import java.lang.reflect.Method;
4 import java.lang.reflect.Modifier;
5 public class StringUtils {
6 @SuppressWarnings("unchecked")
7 public String toString(Object object) {
8 // 获得代表该类的Class对象
9 Class clazz = object.getClass();
10 // 利用StringBuilder来保存字符串
11 StringBuilder sb = new StringBuilder();
12 // 获得类所在的包
13 Package packageName = clazz.getPackage();
14 // 输出类所在的包
15 sb.append("包名：" + packageName.getName() + "\t");
16 String className = clazz.getSimpleName(); // 获得类的简单名称
17 sb.append("类名：" + className + "\n"); // 输出类的简单名称
18 sb.append("公共构造方法：\n");
19 // 获得所有代表构造方法的Constructor数组
20 Constructor[] constructors = clazz.getDeclaredConstructors();
21 for (Constructor constructor : constructors) {
22 String modifier =
23 Modifier.toString(constructor.getModifiers());// 获得方法修饰符
24 if (modifier.contains("public")) {// 查看修饰符是否含“public”
25 sb.append(constructor.toGenericString() + "\n");
26 }
27 }
28 sb.append("公共域：\n");
29 // 获得代表所有域的Field数组
30 Field[] fields = clazz.getDeclaredFields();
31 for (Field field : fields) {
32 String modifier = Modifier.toString(field.getModifiers());
33 if (modifier.contains("public")) {// 查看修饰符是否含“public”
34 sb.append(field.toGenericString() + "\n");
35 }
36 }
37 sb.append("公共方法：\n");
38 // 获得代表所有方法的Method[]数组
39 Method[] methods = clazz.getDeclaredMethods();
40 for (Method method : methods) {
41 String modifier = Modifier.toString(method.getModifiers());
42 // 查看修饰符是否含有“public”
43 if (modifier.contains("public")) {
44 sb.append(method.toGenericString() + "\n");
45 }
46 }
47 return sb.toString();
48 }
49 public static void main(String[] args) {
50 System.out.println(new StringUtils().toString(new Object()));
51 }
52 }
【案例12-2】 速度计算
本案例要求使用反射技术编写一个速度计算程序，计算某种交通工具的行驶速度。现有两种工具：Bike和 Plane，其中Bike的速度运算公式为：A*B/C，Plane的速度运算公式为：A+B+C。
用户可通过输入交通工具名称选择自己想要使用的交通工具，选择交通工具之后，自动计算出该交通工具的行驶速度。此外，在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序即可。
（1）通过任务描述可知，有两种交通工具Plane和Bike：Plane类、Bike类。
（2）由于任务要求在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序，故还需要编写一个接口Common，且Plane类和Bike类都继承Common接口。
（3）最后编写一个测试类CaculateSpeed，在main()方法中，编写程序，提示用户输入自己想要使用的交通工具，并利用反射来计算交通工具的速度。
1 public interface Common {
2 double getSpeed(double a,double b,double c);
3 }
4 public class Bike implements Common {
5 @Override
6 public double getSpeed(double a, double b, double c) {
7 return a*b/c;
8 }
9 }
1 public class Plane implements Common {
2 @Override
3 public double getSpeed(double a, double b, double c) {
4 return a+b+c;
5 }
6 }
1 import java.util.Scanner;
2 public class CaculateSpeed {
3 public static void main(String[] args){
4 Scanner in = new Scanner(System.in);
5 System.out.println("请输入您要使用的交通工具名称：");
6 String choice =in.nextLine();
7 String transport = "fanshe."+choice; //
8 double a = 23, b = 24, c = 25;
9 try {
10 Common newtransport = (Common)
11 Class.forName(transport).newInstance();
12 System.out.println(choice+" speed is :
13 "+newtransport.getSpeed(a,b,c));
14 } catch (InstantiationException e) {
15 e.printStackTrace();
16 } catch (IllegalAccessException e) {
17 e.printStackTrace();
18 } catch (ClassNotFoundException e) {
19 e.printStackTrace();
20 }
21 }
22 }
【案例12-3】：利用反射实现通过读取配置文件对类进行实例化
现在有一个项目，项目中创建了一个Person类，在Person类中定义了一个sleep()方法。在工程中还定义了一个Student类继承Person类，在Student类中重写了Person类的sleep()方法。项目有一个配置文件，名称为test.properties，在配置文件中配置了一个className属性和一个methodName属性，className属性值是类的全限定类名，methodName属性值是方法名。
本案例要求通过读取配置文件对类进行实例化，具体如下：
（1）获取test.properties配置文件中的className属性值（类的全限定类名），利用反射对该类进行实例化。
（2）获取test.properties配置文件中的methodName属性值（方法名），利用反射获取对象方法，并执行该方法。
（1）通过任务描述可知，需要先在工程的根目录下创建一个test.properties文件，在配置文件中配置一个className属性和一个methodName属性，className属性值是类的全限定类名，methodName属性值是方法名。
（2）然后创建两个类：Person类和Student类且Student类继承Person类。在Person类中编写一个sleep()方法，在Student类中重写Person类的sleep()方法；
（3）最后编写一个测试类ReflexTest，在main()方法中，编写程序，具体步骤描述如下：
1.利用反射加载配置文件
2.获取配置文件中的数据，获取类的全路径名及方法名
3.根据获取的类的全路径名，利用反射将该类加载进内存
4.创建该类对象
5.根据在配置文件中获取的方法名获取对象方法
6.执行方法
test.properties
1 className = fanshe.Person
2 methodName = sleep
1 public class Person {
2 public void sleep() {
3 System.out.println("sleep......");
4 }
5 }
1 public class Student extends Person{
2 @Override
3 public void sleep() {
4 super.sleep();
5 System.out.println("呼噜呼噜~~~");
6 }
7 public void s1() {
8 super.sleep();
9 System.out.println("hello");
10 }
11 }
1 import java.io.IOException;
2 import java.lang.reflect.InvocationTargetException;
3 import java.lang.reflect.Method;
4 import java.util.Properties;
5 public class ReflexTest {
6 public static void main(String[] args) throws IOException,
7 ClassNotFoundException, InstantiationException, IllegalAccessException,
8 NoSuchMethodException, SecurityException, IllegalArgumentException,
9 InvocationTargetException {
10 /*1、加载配置文件
11 * 用类名.class.getResourceAsStream("/xx")或者
12 * 类名.class.getClassLoader().getResourceAsStream("xx");
13 * 区别在于前者是需要反斜杠，后者不需要
14 * */
15 Properties properties = new Properties();
16 properties.load(RelectTestMain.class.getResourceAsStream("/test.prope
17 rties"));
18 //2、获取配置文件中定义的数据
19 String className = properties.getProperty("className");
20 String methodName = properties.getProperty("methodName");
21 //3、加载该类进内存
22 Class cls = Class.forName(className);
23 //4、创建类对象
24 Object obj = cls.newInstance();
25 //5、获取对象方法
26 Method method = cls.getMethod(methodName);
27 //6、执行方法
28 method.invoke(obj);
29 }
30 }
只需要修改test.properties配置文件即可。
test.properties
1 sclassName = fanshe.Student
2 methodName = s112.4 本章小结
本章主要介绍了Java的反射机制。首先简单介绍了反射机制；然后介绍了Class类和Class类的应用；最后介绍了反射的应用，包括获取接口、获取方法、获取属性。通过本章的学习，读者对Java的反射会有一定的了解，掌握好这些知识，对以后的实际开发大有裨益。