Java的类加载顺序

1.类加载器

Java虚拟机的类加载过程是由类加载器（ClassLoader）来实现的。类加载器负责将类装载到内存中，并为其创建一个Class对象。Java虚拟机定义了三种类加载器，分别为Bootstrap ClassLoader、Extension ClassLoader、System ClassLoader，它们按照层次关系进行组织，而且每个类加载器都有自己独立的命名空间，保证了不同类加载器之间的隔离性。

2. 加载阶段

类加载过程的第一阶段是加载（Loading），即通过类加载器读取.class文件中的二进制字节流，并将其转换成Java虚拟机中的Class对象。在这个阶段，Java虚拟机将会检查类文件的格式、语义等内容，确保其符合Java规范，否则将抛出ClassFormatError等异常。

3. 验证阶段

在加载完成后，Java虚拟机会对类进行验证（Verification），以确保它的字节码是正确、安全且符合规范的。这个阶段主要有四种验证方式：文件格式验证、元数据验证、字节码验证和符号引用验证。

4. 准备阶段

在验证通过后，Java虚拟机会为类分配内存空间，并进行默认初始化（Prepare），即将类变量分配内存并初始化为二进制零值。这个过程中不会涉及任何Java代码执行，只是简单地为类变量赋予一些初始值。

5. 解析阶段

解析（Resolution）是Java虚拟机将符号引用替换为直接引用的过程。在Java程序中，调用方法或访问对象时通常使用符号引用，需要在运行时将其解析成直接引用才能执行相应的操作。

6. 初始化阶段

当类被加载并初始化后，Java虚拟机会执行其静态初始化器（clinit）中的Java代码。静态初始化器包含了对类中所有静态变量进行赋值操作的Java代码块，它们按照类定义时的顺序依次执行。如果在静态初始化器中发生异常，则该类将被视为无法正确初始化，不允许被使用。

类加载过程总结

Java类加载过程是一个复杂的过程，它涉及到类加载器、运行时数据区等多个方面，并且在不同的阶段都需要完成各种任务，如文件格式验证、元数据验证、符号引用解析等。了解这些过程可以帮助Java开发者更好地理解Java虚拟机的内部实现机制，从而编写出更加高效和优秀的Java代码。

问题：

Q: Java中有哪些类加载器？

A: Java中有三种类加载器：Bootstrap ClassLoader()、Extension ClassLoader和Application ClassLoader。

1）Bootstrap ClassLoader（启动类加载器）：由C++编写，负责加载Java运行环境（JRE）核心库，例如java.lang包等。它是JVM的内置类加载器，在JVM启动时就会被初始化。

2）Extension ClassLoader（扩展类加载器）：用来加载Java扩展库，位于JRE的/lib/ext目录下，或者通过java.ext.dirs系统变量指定的其他目录中。

3）Application ClassLoader（应用程序类加载器）：用来加载应用程序路径上的类，也称为系统类加载器。它是ClassLoader类的子类，通常是由Java应用程序创建的默认类加载器。

 

Q: 类加载器的双亲委派模型是什么？

A: 类加载器的双亲委派模型是指当一个类加载器需要加载一个类时，它首先会将这个任务委托给它的父类加载器去完成，如果父类加载器无法加载，则再由自己来尝试加载。

 

Q: 如何打破类加载器的双亲委派模型？

A: 可以使用线程上下文类加载器（Thread Context ClassLoader）来打破类加载器的双亲委派模型。

Q: 类加载器的缓存机制是什么？

A: 类加载器的缓存机制是指当一个类被某个类加载器加载后，该类及其依赖的类将被缓存到该类加载器中，以供后续使用。

Q: 如何自定义类加载器？

A: 可以通过继承ClassLoader类并重写findClass()方法来自定义类加载器。通常情况下，自定义类加载器会从指定的路径或者网络地址上加载字节码文件。

Q: 什么是热部署（HotSwap）？怎样实现Java代码的热部署？

A: 热部署是指在不停止Java应用程序的情况下，动态地替换或更新Java类或资源文件。实现Java代码的热部署可以使用一些工具，如JRebel、DCEVM等。这些工具通常通过改变类加载器的行为，使得修改后的Java类能够被重新加载到JVM中。

public class ParentClass {
    
    public ParentClass() {
        System.out.println("我是父构造器");
    }

    static {
        System.out.println("我是父静态代码块1");
    }

    static {
        System.out.println("我是父静态代码块2");
    }

    {
        System.out.println("我是父代码块1");
    }

    private int p1 = getValue();

    {
        System.out.println("我是父代码块2");
    }

    private int getValue() {
        System.out.println("我是父成员变量p1");
        return 1;
    }

    private static int getValue2() {
        System.out.println("我是父静态成员变量p2");
        return 1;
    }

    private static int p2 = getValue2();
}

public class ChildClass extends ParentClass {
    
    private int c1 = getValue();

    private static int c2 = getValue2();

    public ChildClass() {
        System.out.println("我是子构造器");
    }

    static {
        System.out.println("我是子静态代码块1");
    }

    static {
        System.out.println("我是子静态代码块2");
    }

    {
        System.out.println("我是子代码块1");
    }

    {
        System.out.println("我是子代码块2");
    }

    private int getValue() {
        System.out.println("我是子成员变量c1");
        return 1;
    }

    private static int getValue2() {
        System.out.println("我是子静态成员变量c2");
        return 1;
    }

    public static void main(String[] args) {
        ChildClass childClass = new ChildClass();
    }
}

 

我是父静态代码块1
我是父静态代码块2
我是父静态成员变量p2
我是子静态成员变量c2
我是子静态代码块1
我是子静态代码块2
我是父代码块1
我是父成员变量p1
我是父代码块2
我是父构造器
我是子成员变量c1
我是子代码块1
我是子代码块2
我是子构造器

 

结论：

先执行父类的静态变量、代码块（哪个在前哪个先执行）---> 再执行子类的静态变量、代码块（哪个在前哪个先执行）

--->再执行父类的普通变量、代码块（哪个在前哪个先执行）--->再执行父类的构造器

--->再执行子类的普通变量、代码块（哪个在前哪个先执行）--->再执行子类的构造器