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. 类对象的创建以及静态块的访问，都会触发类的加载

执行顺序

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