2021.5.21：反射、Class类、动态加载

什么是反射

反射是Reflection，Java中的反射是指程序在运行期间可以拿到一个对象的所有信息。

正常情况下，我们要调用一个对象的方法，或者访问同一个对象的字段，通常会传入对象实例。但是，由于多态的存在，我们经常传入的是某个基类的实例，甚至是最基本的基类——Object类。

所以，反射是为了解决在运行期间，对某个实例一无所知时，如何调用其方法。

Class类

除了int等基本类型外，Java的其他类型全都是class（包括Interface）。class的本质是数据类型。

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信息的方法称为反射。

 

那么，如何获取class的Class实例？有三个方法：

①、通过一个class的静态变量class获取（类名.class）：

Class cls = String.class;

②、如果我们有一个实例变量xxx，可以通过该实例变量提供的getClass方法获取（xxx.getClass()）：

String s = "Hello";
Class cls = s.getClass();

③、如果知道一个class的完整类名，可以通过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();

boolean sameClass = cls1 == cls2; //true

与instanceof的比较

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());
    }
}

注意到数组也是一种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的特性。

动态加载的特性对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。

总结

1、反射：程序在运行期间就能拿到一个对象的所有信息。

区别于静态获取，静态获取调用对象方法时，必须要传入对象实例。

由于多态，我们通常传入的是基类实例，甚至是Object类实例。

2、Class类

JVM在每第一次读取到一种class类型，就将其加载进内存，然后为它创建一个Class实例，并关联起来。

一个Class实例包含了一个class的所有完整信息——name、package、super、interface、field、method。

如果获取了某个Class实例，可以通过这个Class实例获取该实例对应class的所有信息——反射

3、class的Class实例获取方法

//1 知道确定类名时用这种
Class cls = String.class;

//2 多态时常用这种方法
String s = "Hello";
Class cls = s.getClass();

由于每个class是唯一的，所以每个与之对应的Class实例都是唯一的

4、instanceof既可以用来判断类型是否为①某一确定class，也可以判断某个class是否为②某个基类。

5、当用到多态时，我们有了某个基类实例，可以通过它的Class获取实际class信息

6、数组也是一种Class，以String [ ]为例，它的类名是[Ljava.lang.String。此外，基本类型如int，也有其对应的Class，我们可以通过int.class访问

7、如果获取到了一个Class，可以由它的实例方法 xxx.newInstance()来创建对应类型对象

Class cls = String.class;
String s = (String) cls.newInstance();

上述代码相当于new String()。不过通过Class实例创建类对象的局限性在于构造方法——只能调用public的无参构造方法。带参、非public的构造方法都无法调用。

8、JVM执行Java程序时，并不是一次把所有class加载到内存，而是第一次用到时才加载。这就是动态加载。

动态加载的作用：JVM动态加载class的特性，我们才能在运行期间根据条件不同加载不同的实现类。