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<f.length;i++){            //循环输出
                Class<?> 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 = s1

12.4 本章小结

本章主要介绍了Java的反射机制。首先简单介绍了反射机制；然后介绍了Class类和Class类的应用；最后介绍了反射的应用，包括获取接口、获取方法、获取属性。通过本章的学习，读者对Java的反射会有一定的了解，掌握好这些知识，对以后的实际开发大有裨益。