反射
什么是反射？
反射就是Reflection,Java反射是指程序运行期间可以拿到一个对象的一切信息。
正常情况下，如果我们要调用一个对象的方法，或者访问一个对象的字段，通常会传入对象实例：
// Main.java
import com.itranswarp.learnjava.Person;
public class Main {
String getFullName(Person p) {
return p.getFirstName() + " " + p.getLastName();
}
}
jdk编译后生成 String.class文件，
编译Java源码生成“.class”文件里面实际是字节码，而不是可以直接执行的机器码。在运行时，JVM会通过类加载器加载字节码，解释或者编译执行.
而class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时，将其加载进内存。
每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class。它长这样：
public final class Class {
private Class() {}
}
// java.lang包下：
package java.lang;
public final class Class<T> implements Serializable, GenericDeclaration, Type, AnnotatedElement {
private Class(ClassLoader var1) {
this.classLoader = var1;
}
以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 Instance │──────> String
├───────────── ┤
│name = "java.lang.String" │
└──────────────── ┘
┌─────────────────┐
│ Class Instance │──────> Random
├─────────────────┤
│name = "java.util.Random" │
└─────────────────┘
┌──────────────────┐
│ Class Instance │──────> Runnable
├──────────────────┤
│name = "java.lang.Runnable"│
└──────────────────┘
一个Class实例包含了该class的所有完整信息：
┌──────────────────┐
│ Class Instance │──────> String
├─────────────────┤
│name = "java.lang.String" │
├──────────────────┤
│package = "java.lang" │
├──────────────────┤
│super = "java.lang.Object" │
├──────────────────┤
│interface = CharSequence... │
├──────────────────┤
│field = value[],hash,... │
├─────────────────┤
│method = indexOf()... │
└──────────────────┘
由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。
这种通过Class实例获取class信息的方法称为反射（Reflection）。
如何获取一个class的Class实例？有三个方法：
1、静态方法 XXX.class
直接通过一个class的静态变量class获取,这个方法有点像对象访问属性的方法，可以直接.获取Class实例。
Class class1 = String.class;
2、getClass()方法
如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：
String s = "Hello";
Class cls = s.getClass();
3、Class.forName("XXX")获取
方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：
Class cls = Class.forName("java.lang.String");
因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例：
以上三种方法指向的都是同一个class，所以可以用==来比较，只是可以精确地判断数据类型，但不能作子类型比较。JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是动态加载，在运行期根据条件加载不同的实现类。
Class cls1 = String.class;
String s = "Hello";
Class cls2 = s.getClass();
boolean sameClass = cls1 == cls2; // true
注意一下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
public final class Integer extends Number implements Comparable<Integer> {
用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。
通常情况下，我们应该用instanceof判断数据类型，因为面向抽象编程的时候，我们不关心具体的子类型。只有在需要精确判断一个类型是不是某个class的时候，我们才使用==判断class实例。
因为反射的目的是为了获得某个实例的信息。因此，当我们拿到某个Object实例时，我们可以通过反射获取该Object的class信息：
void printObjectInfo(Object obj) {
Class cls = obj.getClass();
}
要从Class实例获取获取的基本信息，参考下面的代码：
public class Main {
public static void main(String[] args) {
printClassInfo("".getClass());
printClassInfo(Runnable.class);
printClassInfo(java.time.Month.class);
printClassInfo(String[].class);
printClassInfo(int.class);
}
static void printClassInfo(Class cls) {
System.out.println("Class name: " + cls.getName());
System.out.println("Simple name: " + cls.getSimpleName());
if (cls.getPackage() != null) {
System.out.println("Package name: " + cls.getPackage().getName());
}
System.out.println("is interface: " + cls.isInterface());
System.out.println("is enum: " + cls.isEnum());
System.out.println("is array: " + cls.isArray());
System.out.println("is primitive: " + cls.isPrimitive());
}
}
注意到数组（例如String[]）也是一种Class，而且不同于String.class，它的类名是[Ljava.lang.String。此外，JVM为每一种基本类型如int也创建了Class，通过int.class访问。
如果获取到了一个Class实例，我们就可以通过该Class实例来创建对应类型的实例：
// 获取String的Class实例:
Class cls = String.class;
// 创建一个String实例:
String s = (String) cls.newInstance();
上述代码相当于new String()。通过Class.newInstance()可以创建类实例，它的局限是：只能调用public的无参数构造方法。带参数的构造方法，或者非public的构造方法都无法通过Class.newInstance()被调用。
动态加载
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的特性，我们才能在运行期根据条件加载不同的实现类。例如，Commons Logging总是优先使用Log4j，只有当Log4j不存在时，才使用JDK的logging。利用JVM动态加载特性，大致的实现代码如下：
// Commons Logging优先使用Log4j:
LogFactory factory = null;
if (isClassPresent("org.apache.logging.log4j.Logger")) {
factory = createLog4j();
} else {
factory = createJdkLog();
}
boolean isClassPresent(String name) {
try {
Class.forName(name);
return true;
} catch (Exception e) {
return false;
}
}
这就是为什么我们只需要把Log4j的jar包放到classpath中，Commons Logging就会自动使用Log4j的原因。
小结
JVM为每个加载的class及interface创建了对应的Class实例来保存class及interface的所有信息；
获取一个class对应的Class实例后，就可以获取该class的所有信息；
通过Class实例获取class信息的方法称为反射（Reflection）；
JVM总是动态加载class，可以在运行期根据条件来控制加载class。
访问字段
对任意的一个Object实例，只要我们获取了它的Class，就可以获取它的一切信息。
我们先看看如何通过Class实例获取字段信息。Class类提供了以下几个方法来获取字段：
-
Field getField(name)：根据字段名获取某个public的field（包括父类） -
Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类） -
Field[] getFields()：获取所有public的field（包括父类） -
Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
我们来看一下示例代码：
XXX.class
类加载器将.class文件加载到内存，代码区
Code Segment
public <A extends Annotation> A[] getAnnotationsByType(Class<A> var1) {
java中有如下几种类加载器:
BootstrapClassLoader 最核心的，load其他的classLoader, 其他的classloader再load其他的Class
- implemented by native language (C/C++/汇编。区别于JRE版本。其他loader都是java写的)(rt.java,没有名字）
- load the core public <A extends Annotation> A[] getAnnotationsByType(Class<A> var1) {
classes of JDK
ExtesionClassLoader 负责JDK的扩展类
-
loader the class from jre/lib/ext
ApplicationClassLoader -
load user-define classes
-
ClassLoader.getSystemClassLoader() == application class loader
other class loaders -
SecureClassLoader
-
URLClassLoader (2/3的父类)
-
user-define ClassLoader
当前装在这个类的classLoader
parent不是指继承，是指那个classLoader引用
jdk classLoader被appClassLoader，找上一层的，如果上一层加载了，就不会再加载，
安全性好！
如果自己写java.lang.String, 破坏性强，但因为上一层加载，就不会加载手写的这个String.
