一、反射
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后， 在堆内存的方法区中就产生了一个Class类型的对象（ 一个类只有一个Class对象） ， 这个对象就包含了完整的类的结构信息。 我们可以通过这个对象看到类的结构。 这个对象就像一面镜子， 透过这个镜子看到类的结构， 所以， 我们形象的称之为： 反射。
Java程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致。
例如：我们某些变量或形参的类型是Object类型，但是程序确需要调用该对象运行时类型的方法，该方法不是Object中方法，那么如何解决呢？
为了解决这些问题，程序需要在运行时发现对象和类的真实信息，我们有两种方法：
（1）第一种是在编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用instanceof运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可。
（2）第二种是编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射。
因为加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
二、动态语言 VS 静态语言【补充】
1、动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言： Object-C、 C#、 JavaScript、 PHP、 Python、 Erlang。
2、静态语言
与动态语言相对应的， 运行时结构不可变的语言就是静态语言。如Java、 C、C++。
Java不是动态语言， 但Java可以称之为“准动态语言” 。 即Java有一定的动态性， 我们可以利用反射机制、 字节码操作获得类似动态语言的特性。
Java的动态性让编程的时候更加灵活！
三、Java 反射机制研究及应用
1、Java 反射机制提供的功能
① 在运行时判断任意一个对象所属的类
② 在运行时构造任意一个类的对象
③ 在运行时判断任意一个类所具有的成员变量和方法
④ 在运行时获取泛型信息
⑤ 在运行时调用任意一个对象的成员变量和方法
⑥ 在运行时处理注解
⑦ 生成动态代理
2、反射相关的主要 API
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
3、反射：框架设计的灵魂
框架：是一个可以供我们使用的半成品软件。可以在框架的基础上进行软件开发，简化编码。
反射：将类的各个组成部分封装为其他对象，这就是反射机制。
好处：
（1）可以在程序运行过程中，操作这些对象。
（2）可以解耦，提供程序的可扩展性。
Java 代码的三个阶段：
4、用途
（1）通过反射在运行时获取类的信息（如：获取属性、属性值、方法、调用方法、获取注解信息、获取泛型实参）；
（2）通过反射在运行时创建任意类型操作对象；
四、反射的强大
1、使用反射之前
创建一个Person类，然后进行操作：
Person：
1 public class Person {
2
3 private String name;
4 public int age;
5
6 @Override
7 public String toString() {
8 return "Person{" +
9 "name='" + name + '\'' +
10 ", age=" + age +
11 '}';
12 }
13
14 public String getName() {
15 return name;
16 }
17
18 public void setName(String name) {
19 this.name = name;
20 }
21
22 public int getAge() {
23 return age;
24 }
25
26 public void setAge(int age) {
27 this.age = age;
28 }
29
30 public Person(String name, int age) {
31
32 this.name = name;
33 this.age = age;
34 }
35
36 private Person(String name) {
37 this.name = name;
38 }
39
40 public Person() {
41 System.out.println("Person()");
42 }
43
44 public void show(){
45 System.out.println("你好，我是一个人");
46 }
47
48 private String showNation(String nation){
49 System.out.println("我的国籍是：" + nation);
50 return nation;
51 }
52 }
反射之前的操作：
1 @Test
2 public void test1() {
3
4 //1.创建Person类的对象
5 Person p1 = new Person("Tom", 12);
6
7 //2.通过对象，调用其内部的属性、方法
8 p1.age = 10;
9 System.out.println(p1.toString());
10
11 p1.show();
12
13 //在Person类外部，不可以通过Person类的对象调用其内部私有结构。
14 //比如：name、showNation()以及私有的构造器
15 }
这样使用，不能调用 Person 类中的私有的结构。
2、使用反射之后
1 @Test
2 public void test2() throws Exception{
3 Class clazz = Person.class;
4 //1.通过反射，创建Person类的对象
5 Constructor cons = clazz.getConstructor(String.class,int.class);
6 Object obj = cons.newInstance("Tom", 12);
7 Person p = (Person) obj;
8 System.out.println(p.toString());
9 //2.通过反射，调用对象指定的属性、方法
10 //调用属性
11 Field age = clazz.getDeclaredField("age");
12 age.set(p,10);
13 System.out.println(p.toString());
14
15 //调用方法
16 Method show = clazz.getDeclaredMethod("show");
17 show.invoke(p);
18
19 System.out.println("*******************************");
20
21 //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
22 //调用私有的构造器
23 Constructor cons1 = clazz.getDeclaredConstructor(String.class);
24 cons1.setAccessible(true);
25 Person p1 = (Person) cons1.newInstance("Jerry");
26 System.out.println(p1);
27
28 //调用私有的属性
29 Field name = clazz.getDeclaredField("name");
30 name.setAccessible(true);
31 name.set(p1,"HanMeimei");
32 System.out.println(p1);
33
34 //调用私有的方法
35 Method showNation = clazz.getDeclaredMethod("showNation", String.class);
36 showNation.setAccessible(true);
37 String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
38 System.out.println(nation);
39
40 }
使用了反射后，可以调用对象内部的私有结构。
五、思考
1、通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用那个？
建议：直接使用 new 的方式
一般情况下，我们都明确所要创建的对象，可以调用类的构造器来创建对象。
使用反射的情况，主要是利用反射的动态性，然后可以动态的来创建对象。
2、反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术？
封装性：封装性主要体现在修饰符上面，即 private 的不能由外部的来直接访问，一方面是为了保护内部的结构和数据，另一方面就是该 private 方法由类中的其他方法调用了，private 的不建议使用，我们直接调用 public 的方法就可以了，
反射：反射机制是告诉我们可以调用 private 的结构，只能告诉我们这样可以做到。
封装性是建议不要直接调用 private 结构，而反射是告诉我们是否可以调用。所以，这两者并不矛盾。
