jvm - 类的初始化过程
加载->链接->初始化
我们知道，我们写的java代码称为源码，想要能够被jvm执行首先需要编译成.class文件，那么编译完到使用又都经理的哪些阶段呢？主要分为以下三个阶段：
- 加载：查找并加载类的二进制数据（.class文件硬盘到内存的一个过程）。
- 连接
- 验证：确保被加载的类的正确性。
- 准备：为类的 静态变量分配内存，并将其初始化为默认值。
- 解析：把类中的符号引用转换为直接引用。 - 初始化：为类的静态变量赋予正确的初始值。
只看概念晦涩生硬，下面通过代码来逐步深入了解：
实例（一）
class Singleton1 {
private static Singleton1 singleton = new Singleton1();
public static int counter1;
public static int counter2 = 0;
public Singleton1() {
counter1++;
counter2++;
}
public static Singleton1 getInstance() {
return singleton;
}
}
class Singleton2 {
public static int counter1;
public static int counter2 = 0;
private static Singleton2 singleton = new Singleton2();
public Singleton2() {
counter1++;
counter2++;
}
public static Singleton2 getInstance() {
return singleton;
}
}
public class Test0010 {
public static void main(String[] args) {
Singleton1 singleton1 = Singleton1.getInstance();
System.out.println(singleton1.counter1);
System.out.println(singleton1.counter2);
Singleton2 singleton2 = Singleton2.getInstance();
System.out.println(singleton2.counter1);
System.out.println(singleton2.counter2);
}
}看一下输出结果是怎么样的：
如果和你想的不一样的话，不要急，继续往下看：
Java程序对类的使用方式可分为两种
- 主动使用
- 被动使用
主动使用
- 创建类的实例
- 访问某个类或接口的静态变量，或者对该静态变量赋值
- 调用类的静态方法
- 反射（如Class.forName(“com.xxx.Test”)）
- 初始化一个类的子类
- Java虚拟机启动时被标明为启动类的类（Java ClassA）
除了主动使用外的其他方式都是被动使用。所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才初始化他们。会过头来解析上面的例子：
我们在使用一个类之前首先要经历：加载->链接->初始化的过程，而在链接阶段又有验证、准备、解析几个过程，重点是准备阶段：为类的 静态变量分配内存，并将其初始化为默认值。这里很重要，也就是我们在首次主动使用类之前，类中的静态变量已经被初始化为了默认值，而在真正的主动使用时才会将静态变量初始化为应有的初始值。来看类Singleton1，在链接阶段过后，类中静态成员的情况是这样子的：
class Singleton1 {
private static Singleton1 singleton = null;
public static int counter1 = 0;
public static int counter2 = 0;
}在Test0010的main方法中，我们调用了Singleton1的如下方法和成员：
/**这里是对Singleton1类的首次主动使用，会引发类的初始化动作*/
Singleton1 singleton1 = Singleton1.getInstance();
System.out.println(singleton1.counter1);
System.out.println(singleton1.counter2);初始化执行过程就是按照顺序执行里面的静态语句和静态代码块。执行private static Singleton1 singleton = new Singleton1(); 时，counter1和counter2均自增，此时counter1和counter2的值均为1，继续往下执行时counter2 又被赋值为0，所以最终
counter1和counter2的值分别为1和0。同样的道理不难看出Singleton2中初始化操作顺序执行静态语句之后，counter1和counter2的值分别为1和1。
实例（二）
class FinalTest1 {
/**
* 编译时常量，访问它不会初始化这个类
*/
public static final int x = 100 / 2;
static {
System.out.println("final block ~~~");
}
}
class FinalTest2 {
/**
* 运行时常量，访问它会初始化这个类
*/
public static final int x = new Random().nextInt(100);
static {
System.out.println("final block ~~~");
}
}
public class Test0020 {
public static void main(String[] args) {
System.out.println(FinalTest1.x);
System.out.println(FinalTest2.x);
}
}运行结果：
我们看到，FinalTest1 中的静态代码块没有执行，而FinalTest2中的静态代码块执行了。
结论：首次主动访问编译时常量，不会初始化这个类；而首次主动访问运行时常量，会初始化这个类。
实例（三）
public class Test0030 {
static {
System.out.println("main static block");
}
public static void main(String[] args) {
System.out.println(Child.b);
}
}
class Parent {
static {
System.out.println("parent static block");
}
}
class Child extends Parent {
static int b = 4;
static {
System.out.println("child static block");
}
}输出结果：
结论：
当初始化一个类时，会先初始化这个类的父类。
实例（四）
public class Test0050 {
public static void main(String[] args) {
System.out.println(Child.a);
}
}
class Parent {
static int a = 3;
static {
System.out.println("parent static block");
}
}
class Child extends Parent {
static {
System.out.println("child static block");
}
}输出结果：
结论：有当程序访问的静态变量或静态方法确实在当前类或接口中定义时，才可以认为是对类的主动使用。
实例（五）
public class Test0060 {
public static void main(String[] args) throws ClassNotFoundException {
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
Class clazz = classLoader.loadClass("com.chengli.jvm.classloader.v0060.CL");
System.out.println("------------------------------");
clazz = Class.forName("com.chengli.jvm.classloader.v0060.CL");
}
}
class CL {
static {
System.out.println("class CL static block");
}
}输出结果：
结论：调用ClassLoader的loadClass方法加载一个类，并不是对类的主动使用。