Java 之 反射机制

反射：框架设计的灵魂

　　框架：是一个可以供我们使用的半成品软件。可以在框架的基础上进行软件开发，简化编码。

　　反射：将类的各个组成部分封装为其他对象，这就是反射机制。

　　　　好处：

　　　　　　1. 可以在程序运行过程中，操作这些对象。

　　　　　　2. 可以解耦，提供程序的可扩展性。

　　Java代码的三个阶段：

 

 　　反射其实就是获取一个类的 Class对象。

一、获取 Class对象 的方式

　　1、使用 Class.forName("全类名")：将字节码文件加载进内存，返回 class 对象

　　　　多用于配置文件，将类名定义在配置文件中，读取文件，加载类。

　　2、类名.class ：通过类名的属性 class 获取

　　　　多用于参数的传递

　　3、对象.getClass()：getClass() 方法在 Object 类中定义了

　　　　多用于对象的获取字节码的方法

　　　注意：同一字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的 Class 对象都是同一个。

　　Demo：

 1   //1.Class.forName("全类名")
 2   Class cls1 = Class.forName("cn.keshi.bean.Person");
 3 
 4   //2.类名.class
 5   Class cls2 = Person.class;
 6 
 7   //3.对象.getClass()
 8   Person p = new Person();
 9   Class cls3 = p.getClass();
10 
11   //== 比较三个对象
12   System.out.println(cls1 == cls2);   //true
13   System.out.println(cls1 == cls3);   //true

 

二、Class 对象功能

　　通过上面的方式获取了 Class 对象，Class 对象包含 Java 类的各个组成部分，因此可以获取里面对应的方法。

　　1、获取成员变量们

 Field[] getFields()： 获取所有 public 修饰的成员变量
 Field getField(String name)：根据字段名来获取 public 修饰的成员变量

 Field[] getDeclaredFields()： 获取所有的成员变量，不考虑修饰符
 Field getDeclaredField(String name)：根据字段名获取成员变量，不考虑修饰符

　　　　获取了对应的类的成员变量，可以进行的操作有：

void set(Object obj, Object value)  // 给成员变量设置值
get(Object obj)                     // 获取成员变量的值
setAccessible(true):暴力反射          // 忽略访问权限修饰符的安全检查

　　　Demo：

 1 public static void main(String[] args) throws Exception {
 2       // 获取Person的Class对象
 3       Class personClass = Person.class;
 4       
 5       //1.Field[] getFields()获取所有public修饰的成员变量
 6       Field[] fields = personClass.getFields();
 7       for (Field field : fields) {
 8           System.out.println(field);
 9       }
10 
11       //2.Field getField(String name)
12       Field a = personClass.getField("a"); 
13       //获取成员变量a 的值
14       Person p = new Person();
15       Object value = a.get(p);
16       System.out.println(value);
17       //设置a的值
18       a.set(p,"张三");
19       System.out.println(p);
20 
21       //3.Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
22       Field[] declaredFields = personClass.getDeclaredFields();
23       for (Field declaredField : declaredFields) {
24           System.out.println(declaredField);
25       }
26 
27       //4.Field getDeclaredField(String name)
28       Field d = personClass.getDeclaredField("d");
29       //忽略访问权限修饰符的安全检查；因为 变量d是用private修饰的，在类外面不支持对私有的变量进行更改，因此需要忽略修饰符
30       d.setAccessible(true);//暴力反射
31       Object value2 = d.get(p);
32       System.out.println(value2);
33       
34 }        

 

　　2、获取构造方法们

 Constructor<?>[] getConstructors()：获取所有的 public 的构造方法
 Constructor<T> getConstructor(类<?>... parameterTypes)：根据构造方法参数的类型来获取构造方法

 Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)：
 Constructor<?>[] getDeclaredConstructors()：

　　获取了对应的类的构造方法，可以进行的操作有：

T newInstance(Object... initargs)：使用参数在创建对象 
newInstance 方法：使用空参数构造方法创建对象，操作可以简化为 Class对象的 newInstance 方法
setAccessible(true):忽略访问权限修饰符的安全检查

　　Demo：

 1 public static void main(String[] args) throws Exception {
 2        // 获取Person的Class对象
 3         Class personClass = Person.class;
 4 
 5        //Constructor<T> getConstructor(类<?>... parameterTypes)
 6         Constructor constructor = personClass.getConstructor(String.class, int.class);   // 获取有参数的构造器
 7         System.out.println(constructor);  
 8          //创建对象
 9         Object person = constructor.newInstance("张三", 23);       // 根据参数创建对象
10         System.out.println(person);
11 
12         Constructor constructor1 = personClass.getConstructor();   // 获取无参数的构造器
13         System.out.println(constructor1);
14         //创建对象
15         Object person1 = constructor1.newInstance();
16         System.out.println(person1);
17 
18         Object o = personClass.newInstance();                     // 简化写法，调用 Class的newInstance 方法
19         System.out.println(o);      
20 }

　

　　3、获取成员方法们

 Method[] getMethods()：
 Method getMethod(String name, 类<?>... parameterTypes)：

 Method[] getDeclaredMethods()
 Method getDeclaredMethod(String name, 类<?>... parameterTypes)

　　　获取了对应的类的成员方法，可以进行的操作有：

Object invoke(Object obj, Object... args) ：执行方法
String getName：获取方法名称

　　Demo：

 1 public static void main(String[] args) throws Exception {
 2         //获取Person的Class对象
 3         Class personClass = Person.class;
 4  
 5         //获取指定名称的方法
 6          Method eat_method = personClass.getMethod("eat");
 7          Person p = new Person();
 8          //执行方法
 9          eat_method.invoke(p);
10 
11          Method eat_method2 = personClass.getMethod("eat", String.class);
12          //执行方法
13         eat_method2.invoke(p,"汉堡包"); 
14  
15          //获取所有public修饰的方法
16          Method[] methods = personClass.getMethods();
17          for (Method method : methods) {
18              System.out.println(method);
19              String name = method.getName();
20              System.out.println(name);
21              //method.setAccessible(true);
22          }
23  }   

 

　　4、获取全类名

String getName()： 获取一个类的（包含包）全类名

　　Demo：

1 //获取Person的Class对象
2 Class personClass = Person.class;
3 //获取类名
4 String className = personClass.getName();
5 System.out.println(className);//cn.java.bean.Person

 

三、案例

　　需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

　　实现步骤：

1 实现技术
2 　　 1. 配置文件
3     2. 反射
4  实现步骤：
5     1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
6     2. 在程序中加载读取配置文件
7     3. 使用反射技术来加载类文件进内存
8     4. 创建对象
9     5. 执行方法

 

　　代码实现：

 1 // 定义的配置文件 pro.properties
 2 className=cn.itcast.domain.Student
 3 methodName=sleep
 4 // 框架类
 5 public class ReflectTest {
 6     public static void main(String[] args) throws Exception {
 7         //可以创建任意类的对象，可以执行任意方法
 8 
 9         /*
10             前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
11          */
12 
13         //1.加载配置文件
14         //1.1创建Properties对象
15         Properties pro = new Properties();
16         //1.2加载配置文件，转换为一个集合
17         //1.2.1获取class目录下的配置文件
18         ClassLoader classLoader = ReflectTest.class.getClassLoader();
19         InputStream is = classLoader.getResourceAsStream("pro.properties");
20         pro.load(is);
21 
22         //2.获取配置文件中定义的数据
23         String className = pro.getProperty("className");
24         String methodName = pro.getProperty("methodName");
25 
26 
27         //3.加载该类进内存
28         Class cls = Class.forName(className);
29         //4.创建对象
30         Object obj = cls.newInstance();
31         //5.获取方法对象
32         Method method = cls.getMethod(methodName);
33         //6.执行方法
34         method.invoke(obj);
35 
36 
37     }
38 }

 

转载于:https://www.cnblogs.com/niujifei/p/11560247.html