第十八章 类加载机制与反射

作为JavaSE学习的最后一章，回顾一下关于注解的学习，其实该内容应该提前学习

• 类加载
• 类连接的过程
• 类初始化的过程
• 类加载器以及实现机制
• 继承ClassLoader实现自定义类加载器
• 使用URLClassLoader
• 使用Class对象
• 方法参数反射
• 动态创建Java对象
• 动态调用方法
• 访问并修改Java对象的属性值
• 使用反射操作数组
• Java1新增的嵌套访问权限
• 使用Proxy和InvocationHandler创建动态代理
• AOP入门
• Class类的泛型
• 通过反射获取泛型类型

本章会深入介绍Java的类加载、连接和初始化知识，并重点介绍Java反射的相关内容。在学习本章的类加载、连接及初始化知识时，可能会感觉这些知识比较底层，但掌握这些底层的运行原理会对Java程序的运行有更好的把握。而且Java加载器除了根类加载器之外，其他类加载器都是使用Java语言编写的，所以程序员完全可以开发自己的类加载器，通过使用自定义类加载器，可以完成一些特定的功能。
本章重点介绍java.lang.reflect包下的接口和累，包括Class、Method、Field、Constructor和Array等，这些类分别代表类、方法、成员变量、构造器和数组，Java程序可以使用这些类动态获取某个对象，某个类的运行时信息，并可以动态地创建Java对象，动态地调用Java方法，访问并修改指定对象的成员变量值。本章还将介绍该包下的Type和ParameterizedType两个接口，其中Type是Class类所实现的接口，而ParameterizedType则代表一个带泛型参数的类型。
本章将介绍使用Proxy和InvocationHandler来创建JDK动态代理，并会通过JDK动态代理向读者介绍高层次解耦的方法，还会讲解JDK动态代理和AOP（Aspect Orient Programming，面向切面编程）之间的内在关系。

系统可能在第一次使用某个类时加载该类，也可能采用预加载机制来加载某个类。本章将会详细介绍类加载、连接和初始化过程中的每一个细节。

当调用java命令运行某个Java程序时，该命令将会启动一个Java虚拟机进程，不管该Java程序有多么复杂，该程序启动了多少个线程，它们都处于该Java虚拟机进程里。正如前面介绍的，同一个JVM的所有线程、所有变量都处于同一个进程里，它们都使用该JVM进程的内存区。当系统出现以下情况时，JVM进程将被终止。

• 程序运行到最后正常结束
• 程序运行使用System.exit()或Runtime.getRuntime().exit()代码处结束程序
• 程序执行过程中遇到并捕获的异常或错误而结束
• 程序所在平台强制结束了JVM进程

从上面的介绍可以看出，当Java程序运行结束时，JVM进程结束，该进程在内存中的状态将会丢失。下面以类的类变量来说明这个问题。下面程序先定义了一个包含类变量的类。

public class A{
    //定义该类的类变量public class ATest1 {
    public static void main(String[] args) {
        //创建A类的实例
        var a = new A();
        //让a实例的类变量a的值自加
        a.a++;
        System.out.println(a.a);
    }
}

    public static int a = 6;
}

上面程序中定义了一个类变量a，接下来定义一个类创建A类的实例，并访问A对象的类变量a

public class ATest1 {
    public static void main(String[] args) {
        //创建A类的实例
        var a = new A();
        //让a实例的类变量a的值自加
        a.a++;
        System.out.println(a.a);
    }
}

下面程序也创建A对象，并访问其类变量a的值

public class ATest2 {
    public static void main(String[] args) {
        //创建A类的实例
        var b = new A();
        //输出b实例的类变量a的值
        System.out.println(b.a);
    }
}

在ATest1.java程序中创建了A类的实例，并让实例的类变量a的值自加，程序输出该实例的类变量a的值将看到7，相信读者对这个答案没有疑问。关键是运行第二个程序ATest2时，程序再次创建了A对象，并输出A对象类变量的a值，此时a的值时多少呢？结果依然是6，并不是7。这是因为运行ATest1和ATest2是两次运行JVM进程，第一次运行JVM结束后，它对A类所做的修改将全部丢失——第二次运行JVM时将再次初始化A类。
在疯狂软件教育中心见过一些学员，他们在回答这个问题时毫不犹豫地说7。他们认为A类里的a成员变量是静态变量（即类变量），同一个类的所有实例的静态变量共享同一块内存区，因为第一次运行时改变了第一个A实例的a变量，所以第二次运行时第二个A实例的a变量也将收到影响。实际上他们忘记了两次运行Java程序处于两个不同的JVM进程中，两个JVM之间并不会共享数据。

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或类初始化。
类加载指的是将类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说，当程序要使用任何累时，系统都会为之建立一个java.lang.Class对象。
前面介绍面向对象时提到：类是某一类对象的抽象，类是概念层次的东西。但不知道读者有没有想过：类也是一种对象。就想平常说的概念主要用于定义、描述其他事物，但概念本身也是一种事物，那么概念本身也需要被描述——这有点像一个哲学命题。但事实就是这样，每个类时一批具有相同特征的对象的抽象（或者说概念），而系统中所有的类实际上也是实例，它们都是java.lang.Class的实例。
类的加载由类加载器完成，类加载器通常由JV,提供，哲学类加载器也是前面所有程序运行的基础，JVM提供的这些类加载器通常被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。
通过使用不同的类加载器，可以从不同来源加载器的二进制数据，通常由如下几种来源。

• 从本地文件系统加载class文件，这是前面绝大部分示例程序的类加载方式。
• 从JAR包加载class文件，这种方式也很常见的，前面介绍JDBC编程时用到的数据库驱动类就放在JAR文件中，JVM可以从JAR文件中直接加载该class文件。
• 通过网络加载class文件。
• 把一个Java源文件动态编译，并执行加载。

类加载器通常无须等到“首次使用”该类时才加载该类，Java虚拟机规范允许系统预先加载某些类。

当类被加载之后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到JRE中。类连接又可分为如下三个阶段。
1 验证：验证阶段用于检验被加载的类是否具有正确的内部结构，并和其他类协调一致。
2 准备：类准备阶段则负责为类的类变量分配内存，并设置默认初始值。
3 解析：将类的二进制数据中的符号引用替换成直接引用

在类的初始化阶段，虚拟机负责对进行初始化，主要就是对类变量进行初始化。在Java类中对类变量指定初始值有两种方式：①声明类变量时指定初始值；②使用静态初始化块为变量指定初始值。例如如下代码片段。

public class Test{
    //声明变量a时指定初始值
    static int a = 5;
    static int b;
    static int c;
    static {
        //使用静态初始化块为变量b指定初始值
        b = 6;
    }
    ...
}

对于上面代码，程序为类变量a、b都显式指定了初始值，所以这两个类变量的值分别为5、6，但变量c则没有指定初始值，它将采用默认初始值0。
声明变量时指定初始值，静态初始化块都将被当成类的初始化语句，JVM会按照这些语句在程序中的排列顺序依次执行它们，例如下面的类

public class Test{
    static {
        //使用静态初始化块为变量b指定初始值
        b = 6;
    }
    static int a = 5;
    static int b = 9; //①
    static int c;

    public static void main(String[] args) {
        System.out.println(Test.b);
    }
}

上面代码先在静态初始化块中为b变量赋值，此时类变量6的值为6；接着程序向下执行，执行到①号代码处，这行代码也属于该类的初始化语句，所以程序再次为变量b赋值。也就是说，当Test类初始化结束后，该类的变量b的值为9。

这里证实了关于顺序执行代码的结果
JVM初始化一个类包含如下几个步骤
1 假如这个类还没有被加载和连接，则程序先加载并连接该类。
2 假如该类的直接父类还没有被初始化，则先初始化其直接父类。
3 假如类中有初始化语句，则系统依次执行这些初始化语句。
当执行第2个步骤时，系统直接对父类的初始化步骤也遵循此步骤1~3；如果该直接父类又有直接父类，则系统再次重复着三个步骤先初始化这个父类…依次类推，所以JVM最先初始化的总是java.lang.Object类。当程序主动使用任何一个类时，系统会保证该类以及所以父类（包括直接父类和间接父类）都会被初始化。

当Java程序首次通过下面6中方式来使用某个类或接口时，系统就会初始化该类或接口。

• 创建类的实例。为某个乐力创建实例的方式包括：使用new操作符来创建实例，通过反射来创建实例，通过反序列化的方式来创建实例。
• 调用某个类的类方法（静态方法）。
• 访问某个类或接口的类变量，或为该类变量赋值。
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。例如代码：Class.forName(“Person”)，如果系统还未初始化Person类，则这行代码将会导致Person类被初始化，并返回Person类对应的java.lang.Class对象。关于Class的forName方法请参考后面的内容
• 初始化某个类的子类。当初始化某个类的子类时，该子类的所有父类都会被初始化。
• 直接使用java.exe命令来运行某个主类。当运行某个主类时，程序会先初始化该主类。
  除此之外，下面的几种情形需要特别指出。
  对于一个final型的类变量，如果该类变量的值在编译时就可以确定下来，那么这个类变量相当于“宏变量”。Java编译器会在编译时直接把这个类变量出现的地方替换成它的值，因此即使程序使用该静态类变量，也不回导致该类的初始化。例如下面示例程序的结果。

class MyTest{
    static{
        System.out.println("静态初始化块...");
    }
    //使用一个字符串直接量为static final的类变量赋值
    static final String compileConstant = "疯狂Java讲义";
}
public class CompileConstanTest{
    public static void main(String[] args) {
        //访问、输出MyTest中的compileConstant类变量
        System.out.println(MyTest.compileConstant);//①
    }
}

上面程序的MyTest类中有一个compileConstant的类变量，该类变量使用了final修饰，而且它的值可以在编译时确定下来，因此compileConstant会被当成“宏变量”处理。程序中所有使用compileConstant的地方都会在编译时被直接替换成它的值——也就是说，上面程序的①号代码在编译时就被替换成了“疯狂Java讲义”，所以该代码不会导致初始化MyTest类。
当某个类变量（也叫静态变量）使用了final修饰，而且它的值可以在编译时就确定下来，那么程序其他地方使用该变量时，实际上并没有使用该类变量，而是相当于使用常量。
反之，如果final修饰的类变量的值不能在编译时确定下来，则必须等到运行时才可以确定该类变量的值，如果通过该类来访问它的类变量，则会导致该类被初始化。例如将上面程序中定义compileConstant的代码改为如下：

  static final String compileConstant = System.currentTimeMillis()+"";

因为上面定义的compileConstant类变量的值必须在运行时才可以确定，所以①号处的代码必须保留对MyTest类的类变量引用，这行代码就变成了使用MyTest的类变量，这将导致MyTest类被初始化。
当使用ClassLoader类的loadClass()方法来加载某个类时，该方法只是加载该类，并不会执行该类的初始化。使用Class的forName()静态方法才会导致强制初始化该类。例如如下代码。

class Tester{
    static {
        System.out.println("Tester类的静态初始化块...");
    }
}
public class ClassLoaderTest{
    public static void main(String[] args) throws ClassNotFoundException{
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        //下面语句仅仅是加载Tester类
        cl.loadClass("Tester");
        System.out.println("系统加载Tester类");
        //下面的语句才会初始化Tester类
        Class.forName("Tester");
    }
}

上面程序可以看出，必须等到执行Class.forName(“Tester”)时才完成对Tester类的初始化

类加载器负责将.class文件(可能在磁盘上，也可能在网络上)加载到内存中，并未之生成对应的java.lang.Class对象。尽管在Java开发中无须过分关心类加载机制，但所有的编程人员都应该了解其工作机制，明白如何做才能让其更好地满足我们的需要。

类加载器负责加载所有的类，系统为所有被载入内存中的类生成一个java.lang.Class实例。一旦一个类被载入JVM中，同一个类就不会被再次载入了。现在的问题是，怎么样才算“同一个类”？
正如一个对象有一个唯一的标识一样，一个载入JVM中的类也有一个唯一的标识。在Java中，一个类用其全限定类名（包括包名和类名）作为标识；但在JVM中，一个类用其全限定类名和其类加载器作为唯一标识。例如，如果在pg的包中有一个名为Person的类，被类加载器ClassLoader的实例kl负责加载，则该Person类对应的Class对象在JVM中表示为（Person、pg、kl）。这意味着两个类加载器加载的同类名：（Person、pg、kl）和（Person、pg、kl2）是不同的，它们所加载的类也是完全不同的、互不兼容的。
当JVM启动时，会形成由三个类加载器组成的初始类加载器层次结构。

• Bootstrap ClassLoader：根类加载器。
• Extension ClassLoader：扩展类加载器。
• System ClassLoader：系统类加载器。

Bootstrap ClassLoader被称为引导（也被称为原始或根）类加载器，它负责加载Java的核心类。在Sun的JVM中，当执行java.exe命令时，使用-Xbootclasspath或-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类。
JVM的类加载机制主要有如下三种。

• 全盘负责。所谓全盘负责就是当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显式使用另外一个类加载器来载入。
• 父类委托。所谓父类委托，则是先让parent(父)类加载器试图加载该Class，只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类。
• 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜索该Class，只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，将其转换成Class对象，存入缓存区中。就这是为什么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。

类加载器之间的父子关系并不是类继承上的父子关系，这里的父子关系是类加载器实例之间的关系。