什么是反射？
反射就是Reflection，Java的反射是指程序在运行期可以拿到一个对象的所有信息。
反射的作用
反射是为了解决在运行期，对某个实例一无所知的情况下，如何调用其方法。
Class 类
class 是一个 java 关键字，表示声明一个类。
除了int等基本类型外，Java的其他类型全部都是class（包括interface）。
class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时，将其加载进内存。
每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class。它长这样：
public final class Class {
private Class() {}
}
以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：
Class cls = new Class(String);
这个Class实例是JVM内部创建的，如果我们查看JDK源码，可以发现Class类的构造方法是private，只有JVM能创建Class实例，我们自己的Java程序是无法创建Class实例的。
所以，JVM持有的每个Class实例都指向一个数据类型（class或interface）：
一个Class实例包含了该class的所有完整信息：
由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。
这种通过Class实例获取class信息的方法称为反射（Reflection）。
如何获取一个class的Class实例？
方法一：直接通过一个class的静态变量class获取：
Class cls = String.class;
方法二：如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：
String s = "Hello";
Class cls = s.getClass();
方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：
Class cls = Class.forName("java.lang.String");
因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。
注意一下Class实例比较和instanceof的差别：
Integer n = new Integer(123);
boolean b1 = n instanceof Integer; // true，因为n是Integer类型
boolean b2 = n instanceof Number; // true，因为n是Number类型的子类
boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class
用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。
通常情况下，我们应该用instanceof判断数据类型，因为面向抽象编程的时候，我们不关心具体的子类型。只有在需要精确判断一个类型是不是某个class的时候，我们才使用==判断class实例。
因为反射的目的是为了获得某个实例的信息。因此，当我们拿到某个Object实例时，我们可以通过反射获取该Object的class信息：
动态加载
JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。例如：
// Main.java
public class Main {
public static void main(String[] args) {
if (args.length > 0) {
create(args[0]);
}
}
static void create(String name) {
Person p = new Person(name);
}
}
当执行Main.java时，由于用到了Main，因此，JVM首先会把Main.class加载到内存。然而，并不会加载Person.class，除非程序执行到create()方法，JVM发现需要加载Person类时，才会首次加载Person.class。如果没有执行create()方法，那么Person.class根本就不会被加载。
这就是JVM动态加载class的特性。
动态加载class的特性对于Java程序非常重要。利用JVM动态加载class的特性，我们才能在运行期根据条件加载不同的实现类。
访问字段
对任意的一个Object实例，只要我们获取了它的Class，就可以获取它的一切信息。
我们先看看如何通过Class实例获取字段信息。Class类提供了以下几个方法来获取字段：
-
Field getField(name)：根据字段名获取某个public的field（包括父类）
-
Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
-
Field[] getFields()：获取所有public的field（包括父类）
-
Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
我们来看一下示例代码：
public class Main {
public static void main(String[] args) throws Exception {
Class stdClass = Student.class;
// 获取public字段"score":
System.out.println(stdClass.getField("score"));
// 获取继承的public字段"name":
System.out.println(stdClass.getField("name"));
// 获取private字段"grade":
System.out.println(stdClass.getDeclaredField("grade"));
}
}
class Student extends Person {
public int score;
private int grade;
}
class Person {
public String name;
}
上述代码首先获取Student的Class实例，然后，分别获取public字段、继承的public字段以及private字段，打印出的Field类似：
public int Student.score
public java.lang.String Person.name
private int Student.grade
小结
-
Java的反射API提供的Field类封装了字段的所有信息：
-
通过Class实例的方法可以获取Field实例：getField()，getFields()，getDeclaredField()，getDeclaredFields()；
-
通过Field实例可以获取字段信息：getName()，getType()，getModifiers()；
-
通过Field实例可以读取或设置某个对象的字段，如果存在访问限制，要首先调用setAccessible(true)来访问非public字段。
-
通过反射读写字段是一种非常规方法，它会破坏对象的封装。
调用方法
Java的反射API提供的Method对象封装了方法的所有信息：
通过Class实例的方法可以获取Method实例：
-
getMethod()
-
getMethods()
-
getDeclaredMethod()
-
getDeclaredMethods()
通过Method实例可以获取方法信息：
-
getName()
-
getReturnType()
-
getParameterTypes()
-
getModifiers()
通过Method实例可以调用某个对象的方法：Object invoke(Object instance, Object... parameters)；
通过设置setAccessible(true)来访问非public方法；
通过反射调用方法时，仍然遵循多态原则。
调用构造方法
Constructor对象封装了构造方法的所有信息；
通过Class实例的方法可以获取Constructor实例：
-
getConstructor()：获取某个public的Constructor
-
getConstructors()：获取所有public的Constructor
-
getDeclaredConstructor()：获取某个Constructor
-
getDeclaredConstructors()：获取所有Constructor
通过Constructor实例可以创建一个实例对象：newInstance(Object... parameters)；
通过设置setAccessible(true)来访问非public构造方法。
获取继承关系
当我们获取到某个Class对象时，实际上就获取到了一个类的类型：
Class cls = String.class; // 获取到String的Class
还可以用实例的getClass()方法获取：
String s = "";
Class cls = s.getClass(); // s是String，因此获取到String的Class
最后一种获取Class的方法是通过Class.forName("")，传入Class的完整类名获取：
Class s = Class.forName("java.lang.String");
这三种方式获取的Class实例都是同一个实例，因为JVM对每个加载的Class只创建一个Class实例来表示它的类型。
获取父类的Class
有了Class实例，我们还可以获取它的父类的Class：
public class Main {
public static void main(String[] args) throws Exception {
Class i = Integer.class;
Class n = i.getSuperclass();
System.out.println(n);
Class o = n.getSuperclass();
System.out.println(o);
System.out.println(o.getSuperclass());
}
}
输出：
class java.lang.Number
class java.lang.Object
null
运行上述代码，可以看到，Integer的父类类型是Number，Number的父类是Object，Object的父类是null。
除Object外，其他任何非interface的Class都必定存在一个父类类型.
通过Class对象可以获取继承关系：
-
Class getSuperclass()：获取父类类型；
-
Class[] getInterfaces()：获取当前类实现的所有接口。
通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现.
动态代理
Java标准库提供了一种动态代理（Dynamic Proxy）的机制：可以在运行期动态创建某个interface的实例。
什么叫运行期动态创建？听起来好像很复杂。所谓动态代理，是和静态相对应的。我们来看静态代码怎么写：
定义接口：
public interface Hello {
void morning(String name);
}
编写实现类：
public class HelloWorld implements Hello {
public void morning(String name) {
System.out.println("Good morning, " + name);
}
}
创建实例，转型为接口并调用：
Hello hello = new HelloWorld();
hello.morning("Bob");
这种方式就是我们通常编写代码的方式。
还有一种方式是动态代码，我们仍然先定义了接口Hello，但是我们并不去编写实现类，而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。
这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。
JDK提供的动态创建接口对象的方式，就叫动态代理。
在运行期动态创建一个interface实例的方法如下：
-
定义一个InvocationHandler实例，它负责实现接口的方法调用；
-
通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：
- 使用的ClassLoader，通常就是接口类的ClassLoader；
- 需要实现的接口数组，至少需要传入一个接口进去；
- 用来处理接口方法调用的InvocationHandler实例。
将返回的Object强制转型为接口。
每天学习一点点，每天进步一点点。