反射之初认识

除了int等基本类型外，Java的其余类型所有都是class（包括interface）。
仔细思考，咱们能够得出结论：class（包括interface）的本质是数据类型（Type）。
而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）

 

因为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实例：

Class cls1 = String.class;
String s = "hello";
Class cls2 = s.getClass();
System.out.println(cls1 == cls2); // true

由于反射的目的是为了得到某个实例的信息。所以，当咱们拿到某个Object实例时，咱们能够经过反射获取该Object的class信息：

 1 public class Demo{
 2     public static void main(String[] args) {
 3         printObjectInfo("wang");
 4     }
 5     
 6     public static void printObjectInfo(Object object){
 7         Class cls = object.getClass();
 8         System.out.println(cls);  //class java.lang.String
 9     }
10 }

要从Class实例获取某个class的基本信息

 1 public class Demo12{
 2     public static void main(String[] args) {
 3         //字符串实例
 4         printClassInfo("".getClass());
 5         System.out.println("****************");
 6         //Runnable接口
 7         printClassInfo(Runnable.class);
 8         System.out.println("****************");
 9         printClassInfo(java.time.Month.class);
10         System.out.println("****************");
11         printClassInfo(int[].class);
12         System.out.println("****************");
13         printClassInfo(long.class);
14     }
15     
16     static void printClassInfo(Class cls){
17         //class全限定类名
18         System.out.println("Class name:" + cls.getName());
19         //class类名
20         System.out.println("Simple name:" + cls.getSimpleName());
21         //包名
22         if(cls.getPackage() != null){
23             System.out.println("Package name:" + cls.getPackage().getName());
24         }
25         //判断该类是不是接口
26         System.out.println("is interface:" + cls.isInterface());
27         //判断该类是不是枚举
28         System.out.println("is enum:" + cls.isEnum());
29         //判断该类是不是数组
30         System.out.println("is array:" + cls.isArray());
31         //判断该类是不是基本类型
32         System.out.println("is primitive:" + cls.isPrimitive());
33     }
34 }

若是获取到了一个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时才加载。

 1 public class Demo{
 3     public static void main(String[] args){
 4         if(args.length > 0){
 5             create(args[0]);
 6         }
 7     }
 8     
 9     static void create(String name){
10         Person p = new Person(name);
11     }
12     
13 }

当执行Demo.java时，因为用到了Demo,所以，JVM首先会把Demo.class加载到内存。然而，并不会加载Person.class,除非程序执行到create()方法，JVM发现须要加载Person类时，才会首次加载Person.class。若是没有执行create()方法，那么Person.class根本就不会被加载

这就是JVM动态加载class的特性

动态加载class的特性对于Java程序很是重要。利用JVM动态加载class的特性，咱们才能在运行期根据条件加载不一样的实现类。例如，Commons Logging老是优先使用Log4j,只有当Log4j不存在时，才使用JDK的logging.利用JVM动态加载特性，大体的实现代码以下：

 1 //Commons logging优先使用Log4j
 2     LogFactory factory =  null;
 3     if(isClassPresent("org.apache.logging.log4j.Logger")){
 4         factory = createLog4j();
 5     }else{
 6         factory = createJdkLog();
 7     }
 8     
 9     boolean isClassPresent(String name){
10         try{
11             Class.forName(name);
12             return true;
13         }catch(Exception e){
14             return false;
15         }
16         
17     }

这就是为何咱们只须要吧Log4j的jar包放到classpath中，Commons Logging就会自动使用Log4j的缘由

小结

1.JVM为每一个加载的class及interface建立了对应的Class实例来保存class及interface的全部信息；

2.获取一个class对应的Class实例后，就能够获取该class的全部信息；

3.经过Class实例获取class信息的方法称为反射（Reflection）；

4.JVM老是动态加载class，能够在运行期根据条件来控制加载class。