JJVM类的加载过程

类的加载过程

一个java文件从被加载到被卸载 这个生命过程，总共要经理五个阶段，JVM将类加载过程分为：（加链初使卸）

1. 加载

首先通过一个类的全限定名 来获取此类的二进制字节流 ；其次将这个字节流所代表的静态存储结构 转化为方法区 的运行时数据结构 ；最后在java堆中生成一个代表这个类的Class对象 ，作为方法区 这些数据的访问入口。总的来说就是查找并加载类的二进制数据。

2. 链接

验证：确保被加载类的正确性，字节码开头必须为cafebabe

准备：为类的静态变量分配内存，并将其初始化为默认值

解析：把类中的符号引用转换为直接引用

3. 类的初始化

1> 类什么时候才被初始化

• 创建类的实例，也就是new一个对象

• 访问某个类或接口的静态变量，或者对该静态变量赋值

• 调用类的静态方法

• 反射（Class.forName(类路径)）

• 初始化一个类的子类（会首先初始化子类的父类）

• JVM启动时标明的启动类，即文件名和类名相同的那个类

  另外：

  1、类中的static final 修饰的基本数据类型及String类型成员变量，被访问是不会触发类初始化的；

  2、静态内部类也是被访问不会触发类初始化；

2>类的初始化顺序

1. 如果这个类还没有被加载和链接，那先进行加载和链接

2. 假如这个类存在直接父类，并且这个类还没有被初始化（注意：在一个类加载器中，类只能初始化一次），那就初始化直接的父类（不适用于接口）

3. 加入类中存在初始化语句（如static变量和static块），那就一次执行这些初始化语句

4. 总的来说，初始化顺序依次是：（静态变量、静态初始化块）->（变量、初始化块）-> 构造器

如果有父类，则顺序是：

父类static方法 -> 子类static方法 -> 父类构造方法 -> 子类构造方法

4. 类的加载

类的加载指的是将类的.class文件中的二进制数据读入内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个这个类的java.lang.Class对象。

先将类的字节码文件读入内存，放入方法区中，然后在堆中创建一个该类的Class对象

如：

类的加载的最终产品是位于堆中的Class对象。Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。加载类的方式有以下几种：

1. 从本地系统直接加载

2. 通过网络下载.class文件

3. 从zip，jar等归档文件中加载.class文件

4. 从专有数据库中提取.class文件

5. 将Java源文件动态编译为.class文件（服务器）

5.加载器

JVM的类加载是通过ClassLoader及其子类来完成的，类的层次关系和加载顺序可以由下图来描述：

加载器介绍：

1）BootstrapClassLoader（启动类加载器） 　　负责加载$JAVA_HOME中jre/lib/rt.jar里所有的class，加载System.getProperty("sun.boot.class.path")所指定的路径或jar。 2）ExtensionClassLoader（标准扩展类加载器） 　　负责加载java平台中扩展功能的一些jar包，包括$JAVA_HOME中jre/lib/*.jar或-Djava.ext.dirs指定目录下的jar包。载System.getProperty("java.ext.dirs")所指定的路径或jar。 3）AppClassLoader（系统类加载器） 　　负责记载classpath中指定的jar包及目录中class 4）CustomClassLoader（自定义加载器） 　　属于应用程序根据自身需要自定义的ClassLoader，如tomcat、jboss都会根据j2ee规范自行实现。

（2）类加载器的顺序 1）加载过程中会先检查类是否被已加载，检查顺序是自底向上 ，从Custom ClassLoader到BootStrap ClassLoader逐层检查，只要某个classloader已加载就视为已加载此类，保证此类只所有ClassLoader加载一次。而加载的顺序是自顶向下，也就是由上层来逐层尝试加载此类。 2）在加载类时，每个类加载器会将加载任务上交给其父，如果其父找不到，再由自己去加载。

3）Bootstrap Loader（启动类加载器）是最顶级的类加载器了，其父加载器为null。

public class Demo {
    public static void main(String[] args) {
        C c = new C();
    }
}
class A{
    static {
        System.out.println("A static");
    }
}
​
class B extends A{
    static {
        System.out.println("B static");
    }
}
​
class D{
    static {
        System.out.println("D static");
    }
}
​
class C extends B{
    private static D d = new D();
    static {
        System.out.println("C static");
    }
}

打印

A static
B static
D static
C static

在上面的例子中，类C继承于B，B继承于A，C又依赖于D，在创建C时，会自动加载C继承的B和依赖的D，然后B又继承于A，先加载A，再加载B，再加载D，最后加载D

继承的优先级大于依赖

所有的变量初始化完，才会执行构造方法

在类的加载过程中，只有内部的变量创建完，才会去执行这个类的构造方法。

// 静态块 和 构造方法的加载顺序
public class ConstructorStep {
    public static void main(String[] args) {
        A2 a2 = new A2();
    }
}
​
class D2{
    static {
        System.out.println("D2 static");
    }
    public D2(){
        System.out.println("D2 constructor");
    }
}
​
class C2{
    static {
        System.out.println("C2 static");
    }
    public C2(){
        System.out.println("C2 constructor");
    }
}
​
class B2{
    C2 c2 = new C2();
    D2 d2 = new D2();
    static {
        System.out.println("B static");
    }
    public B2(){
        System.out.println("B2 constructor");
    }
}
​
class A2{
    B2 b2 = new B2();
    static {
        System.out.println("A static");
    }
    public A2(){
        System.out.println("A2 constructor");
    }
}

打印：

A static
B static
C2 static
C2 constructor
D2 static
D2 constructor
B2 constructor
A2 constructor
​

先创建A，执行A的静态块，再加载A的成员变量B2，

执行B2的静态块，再加载B的成员变量C2，D2，

执行C2的静态块，由于C2中没有成员变量需要加载，再执行C2的空参构造方法。

执行D2的静态块，同C2一样。

B2的成员变量加载完了，执行B2的构造方法

最后，A2同B2一样

---

总结

1. 所有的类都会优先加载基类

2. 静态成员的初始化优先

3. 成员初始化完后，才会执行构造方法

4. 静态成员的初始化与静态块的执行，发生在类加载的时候，静态成员的优先级大于静态块

5. 类对象的创建以及静态块的访问，都会触发类的加载

执行顺序

静态成员变量 -> 静态代码块 -> 成员变量 -> 构造方法