反射：框架设计的灵魂
框架：是一个可以供我们使用的半成品软件。可以在框架的基础上进行软件开发，简化编码。
反射：将类的各个组成部分封装为其他对象，这就是反射机制。
好处：
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 }
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
