虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。
1.类的生命周期
从图中可以看到，类的生命周期共有7个阶段：加载->验证->准备->解析->初始化->使用->卸载，其中验证、准备、解析这3个阶段合起来又称为连接阶段。
虚拟机规范定义了以下4种情况必须立即对类进行初始化：
- 遇到new、getstatic、putstatic、invokestatic这4条字节码指令时，如果类还没有初始化过则先对其进行初始化。与这几条指令对应的场景通常有：采用new关键字实例化一个类的对象、读取或设置类的静态字段（被final关键字修饰并且在编译期已经生成常量的除外）、调用类的静态方法；
- 对类进行反射调用时，如果该类还没有初始化，则先触发其初始化；
- 当对类进行初始化时，如果发现其父类还没有初始化过，则先触发其父类的初始化；
- 当虚拟机启动时，会先对入口类（包含main()方法的类）进行初始化；
以上这4种引用方式都称为对类的主动引用，有且只有这4种引用方式会触发类的初始化，其他引用方式都是类的被动引用方式，均不会触发类的初始化，例如以下几种被动引用方式：
- 通过子类调用父类的静态变量、静态方法不会触发子类初始化
public class SuperClass {
public static String name = "super";
static {
System.out.println("super class init...");
}
public static void callSuper() {
System.out.println("method called in super class...");
}
}
public class ChildClass extends SuperClass{
static {
System.out.println("child class init...");
}
}
测试代码：
public static void main(String[] args) throws ClassNotFoundException {
System.out.println("print super class name: " + ChildClass.name);
ChildClass.callSuper();
}
测试结果如下：
super class init...
print super class name: super
method called in super class...
这里可以看到，子类引用了父类的静态变量，通过子类调用了父类的静态方法，但是只触发了父类的初始化，并没有触发子类的初始化。对于静态字段以及静态方法调用，只有直接定义这个字段和方法的类才会被初始化。
- 对类里的常量字段进行引用不会触发类的初始化
public class ConstClass {
public static int a = 10;
static {
System.out.println("ConstClass init...");
}
}
public class ConstClass2 {
public static final int a = 10;
static {
System.out.println("ConstClass2 init...");
}
}
测试代码：
public static void main(String[] args) throws Throwable {
System.out.println(ConstClass.a);
System.out.println(ConstClass2.a);
}
测试结果如下：
ConstClass init...
10
10
从以上结果可以看到，ConstClass有触发类的初始化，ConstClass2并没有触发类的初始化，这是因为ConstClass2的字段是static final修饰的，在编译的时候该字段值已放到常量池里了，对该字段的引用仅仅是对常量池里该常量的引用。
- 通过数组定义来引用类不会触发类的初始化
public static void main(String[] args) throws Throwable {
SuperClass[] arr = new SuperClass[10];
}
定义了一个一维数组，这样并不会触发类的初始化。
2.加载
- 通过类的全限定名来获取定义此类的二进制字节流；
- 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
- 在Java堆中生成一个代表这个类的java.lang.Class对象，作为方法区这些数据的访问入口；
3.验证
验证阶段主要是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。大致分为4个阶段：文件格式验证、元数据验证、字节码验证、符号引用验证。
4.准备
准备阶段主要是为类变量分配内存并设置初始值，这些内存都将在方法区中进行分配。 类变量一般指static修饰的变量，通常情况下初始值指的是数据类型的零值。例如：
public static int a = 10;
对于以上代码，准备阶段会将变量a的值设置为初始值0而不是10，设置成10是在类的初始化阶段里执行类的构造方法<clinit>()时发生的。
public static final int a = 10;
相比之前对字段a的定义这里多了final修饰，在编译时生成的该字段信息的属性表中会有一个ConstantValue属性，该ConstantValue的属性值为字面量10，这样在准备阶段会将字段a的初始值直接设置为10。
5.解析
解析是将常量池内的符号引用转换为直接引用的过程，主要包括4种解析过程：类或接口的解析、字段解析、类方法解析、接口方法解析。
- 符号引用：以一组符号来描述所引用的目标，它与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中；
- 直接引用：它可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄，直接引用是与虚拟实现的内存布局相关的，直接引用的目标是一定存在于内存中的。
两者的区别可以简单理解为，直接引用就是对目标对象在内存中地址的引用，符号引用描述的只是一个字面上的逻辑关系，并不一定会反映到具体的内存上。
6.初始化
类初始化是比较关键的一步，前面几个步骤都是由虚拟机来主导执行的，它具体是怎么执行的我们并不清楚，到这一步才真正开始与我们写的java代码相关联起来。
初始化阶段是执行类构造器<clinit>()方法的过程。
- <clinit>()方法是由编译器自动收集类中的类变量赋值动作和静态语句块（static {}块）中的语句合并产生的；
- 虚拟机会保证子类的<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕。由于java.lang.Object是所有类的父类，所以肯定是java.lang.Object类的<clinit>()方法第一个执行；
- <clinit>()方法对于类和接口来说并不是必须的，例如类中没有静态语句块，也没有静态变量，这样并不一定会生成<clinit>()方法；
- 虚拟机在执行类的<clinit>()方法时会进行加锁同步，由虚拟机来保证<clinit>()方法只会执行一次；
以下情况不会生成<clinit>()方法：
1.类中没有任何类变量（staitc修饰的字段）以及静态语句块；
2.类中只有static final修饰的字段，这只会在常量池中生成一个常量；
3.类中虽然有类变量，但是并没有赋值动作；
public class TestInitClass {
public static final int A = 0;
public static int B;
}
以上代码编译时并不会生成<clinit>()方法，字段“A”是static final修饰的，会在编译时生成一个ConstantValue常量，字段“B”虽然不会生成常量，但是代码里并没有对其进行赋值，所以编译时并不会生成<clinit>()方法。
典型的会生成<clinit>()方法的代码如下：
public class TestInitClass {
public static int A = 0;
static {
System.out.println("");
}
}
7.接口的初始化
看到相关资料说，接口类在编译时也会生成<clinit>()方法。首先关于接口类有2点必须先清楚：1.接口类里不能定义静态语句块；2.接口类里的字段会被自动转为public static final类型的，不管代码里有没有为变量定义public static final这几个关键字。鉴于这2点，本人对接口类也会生成<clinit>()方法存疑，前面说明过这种情况下并不会生成<clinit>()方法，本着怀疑的态度自己编写一个测试类来看看：
public interface TestInterface {
int b = 10;
void test();
}
对该接口采用javac命令编译后再用javap -v TestInterface.class命令查看字节码信息：
public interface TestInterface
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT
Constant pool:
#1 = Class #11 // TestInterface
#2 = Class #12 // java/lang/Object
#3 = Utf8 b
#4 = Utf8 I
#5 = Utf8 ConstantValue
#6 = Integer 10
#7 = Utf8 test
#8 = Utf8 ()V
#9 = Utf8 SourceFile
#10 = Utf8 TestInterface.java
#11 = Utf8 TestInterface
#12 = Utf8 java/lang/Object
{
public static final int b;
descriptor: I
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
ConstantValue: int 10
public abstract void test();
descriptor: ()V
flags: ACC_PUBLIC, ACC_ABSTRACT
}
SourceFile: "TestInterface.java"
从上面可以看出：
1.虽然代码里我们定义的是“int b”，但是编译后的字节码里“b”的实际类型是“public static final int b”；
2.这里并没有<clinit>()方法生成；
这仅仅是个人的见解，并不一定正确，欢迎批评指正。
java类加载机制系列文章：
