类加载流程之初始化：静态代码块的深入拷打

一、Java类加载顺序详解

在Java中，类的加载顺序是一个非常重要的知识点，尤其是在理解类的初始化、对象创建以及静态与非静态资源的执行顺序时。以下是Java类中各种代码块和方法的加载与执行顺序的详细分析。

1. 类加载过程

Java类的加载由JVM（Java虚拟机）完成，主要经历以下几个阶段：

加载（Loading） ：JVM通过类加载器（ClassLoader）将类的.class文件加载到内存中。
链接（Linking） ：
- 验证（Verification）：确保字节码文件的正确性和安全性。
- 准备（Preparation）：为类的静态变量分配内存，并设置默认初始值（如int为0，Object为null）。
- 解析（Resolution）：将符号引用转换为直接引用。
初始化（Initialization） ：执行类的初始化代码，包括静态变量赋值和静态代码块的执行。

2. 类的初始化顺序

当一个类被首次使用时（例如创建对象、访问静态成员、通过反射加载等），JVM会触发类的初始化。以下是类初始化的详细顺序：

父类静态成员与静态代码块：
- 如果类有父类，先初始化父类的静态变量（按代码中声明的顺序）和静态代码块（按代码中出现的顺序）。
- 静态代码块和静态变量的初始化是交织执行的，遵循代码的书写顺序。
子类静态成员与静态代码块：
- 初始化子类的静态变量和静态代码块，规则同上。
父类普通成员与普通代码块：
- 当创建对象时，先初始化父类的普通成员变量（按声明顺序）和普通代码块（按出现顺序）。
- 普通代码块和普通成员变量的初始化也是交织执行的。
父类构造方法：
- 执行父类的构造方法，完成父类对象的初始化。
子类普通成员与普通代码块：
- 初始化子类的普通成员变量和普通代码块。
子类构造方法：
- 执行子类的构造方法，完成子类对象的初始化。

3. 方法的执行时机

静态方法：
- 静态方法属于类，不需要对象实例即可调用。
- 静态方法在类初始化后即可被调用，但不会主动执行，除非被显式调用。
普通方法：
- 普通方法属于对象实例，必须在对象创建后才能调用。
- 普通方法不会在类加载或对象初始化时自动执行，只有在程序显式调用时才会执行。

4. 注意事项

静态代码块只在类加载时执行一次，且仅执行一次。
普通代码块在每次创建对象时都会执行。
构造方法 在每次创建对象时都会被调用，且子类构造方法会隐式或显式调用父类的构造方法（通过super()）。
如果类没有被使用（例如没有创建对象或调用静态成员），则不会触发初始化。

5. 示例代码

以下是一个示例代码，用于展示Java类中各种代码块和方法的执行顺序：

csharp 复制代码

class Parent {
    // 静态变量
    static String staticField = getStaticField();
    
    // 静态代码块
    static {
        System.out.println("Parent static block");
    }
    
    // 普通变量
    String field = getField();
    
    // 普通代码块
    {
        System.out.println("Parent instance block");
    }
    
    // 构造方法
    public Parent() {
        System.out.println("Parent constructor");
    }
    
    // 静态方法
    private static String getStaticField() {
        System.out.println("Parent static field initialization");
        return "Parent static field";
    }
    
    // 普通方法
    private String getField() {
        System.out.println("Parent instance field initialization");
        return "Parent field";
    }
}

class Child extends Parent {
    // 静态变量
    static String childStaticField = getChildStaticField();
    
    // 静态代码块
    static {
        System.out.println("Child static block");
    }
    
    // 普通变量
    String childField = getChildField();
    
    // 普通代码块
    {
        System.out.println("Child instance block");
    }
    
    // 构造方法
    public Child() {
        System.out.println("Child constructor");
    }
    
    // 静态方法
    private static String getChildStaticField() {
        System.out.println("Child static field initialization");
        return "Child static field";
    }
    
    // 普通方法
    private String getChildField() {
        System.out.println("Child instance field initialization");
        return "Child field";
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Main start");
        Child child = new Child();
        System.out.println("Main end");
    }
}

输出结果：

scss 复制代码

Main start
Parent static field initialization
Parent static block
Child static field initialization
Child static block
Parent instance field initialization
Parent instance block
Parent constructor
Child instance field initialization
Child instance block
Child constructor
Main end

分析：

程序开始运行，main方法首先输出"Main start"。
创建Child对象，触发Child类的初始化：
- 先初始化父类Parent的静态成员和静态代码块：
  - 执行staticField初始化，调用getStaticField()，输出"Parent static field initialization"。
  - 执行静态代码块，输出"Parent static block"。
- 再初始化Child的静态成员和静态代码块：
  - 执行childStaticField初始化，调用getChildStaticField()，输出"Child static field initialization"。
  - 执行静态代码块，输出"Child static block"。
初始化Child对象：
- 先初始化父类Parent的普通成员和代码块：
  - 执行field初始化，调用getField()，输出"Parent instance field initialization"。
  - 执行普通代码块，输出"Parent instance block"。
  - 执行Parent构造方法，输出"Parent constructor"。
- 再初始化Child的普通成员和代码块：
  - 执行childField初始化，调用getChildField()，输出"Child instance field initialization"。
  - 执行普通代码块，输出"Child instance block"。
  - 执行Child构造方法，输出"Child constructor"。
最后，main方法输出"Main end"。

二、模拟面试场景

以下是一个模拟面试场景，面试官将围绕Java类加载顺序对你进行提问，涵盖基础到深入的内容，并可能设置一些陷阱问题。

面试官提问

面试官：你好！今天我们来聊聊Java类的加载顺序。请你详细讲解一下Java中类的初始化过程，以及静态代码块、普通代码块、构造方法等的执行顺序。

你的回答：当JVM加载一个类时，会经历加载、链接和初始化三个阶段。初始化阶段是类加载顺序的核心，主要包括以下步骤：

如果有父类，先初始化父类的静态变量和静态代码块，按代码顺序执行。
初始化子类的静态变量和静态代码块。
当创建对象时，先初始化父类的普通成员变量和普通代码块，再调用父类的构造方法。
最后初始化子类的普通成员变量、普通代码块和构造方法。静态方法和普通方法不会主动执行，只有在显式调用时才会运行。

面试官：很好！那静态代码块和静态变量的初始化有什么区别？如果我在静态代码块中访问一个还未初始化的静态变量，会发生什么？

你的回答 ：静态代码块和静态变量的初始化都是在类初始化阶段完成的，且按代码的书写顺序执行。静态变量可以在声明时直接赋值，也可以在静态代码块中赋值。如果在静态代码块中访问一个还未初始化的静态变量，会得到该变量的默认值（例如int为0，Object为null），因为JVM在准备阶段已经为所有静态变量分配了内存并设置了默认值。如果代码逻辑导致访问未初始化变量的复杂依赖，可能抛出ExceptionInInitializerError。

面试官：不错！那如果我有一个类，里面既有静态代码块也有普通代码块，我创建了两个对象，这两个代码块分别会执行几次？

你的回答：静态代码块只在类初始化时执行一次，无论创建多少个对象都不会再次执行。普通代码块在每次创建对象时都会执行。因此，如果创建两个对象，静态代码块执行1次，普通代码块执行2次。

面试官 ：假设我有一个父类和子类，子类的构造方法没有显式调用super()，会发生什么？构造方法的执行顺序是怎样的？

你的回答 ：如果子类的构造方法没有显式调用super()，编译器会自动在子类构造方法的第一行插入一个调用父类无参构造方法的super()。如果父类没有无参构造方法，编译会报错。构造方法的执行顺序是：

先调用父类的构造方法（包括父类构造方法中隐含的普通代码块和成员变量初始化）。
再执行子类的构造方法（包括子类的普通代码块和成员变量初始化）。

面试官：很好！那我再问一个深入点的问题。如果我在静态代码块中尝试创建当前类的对象，会发生什么？为什么？

你的回答 ：在静态代码块中创建当前类的对象会导致StackOverflowError。原因是静态代码块在类初始化时执行，而创建对象会触发类的初始化（如果类尚未完全初始化）。这会形成递归调用：静态代码块 → 创建对象 → 触发类初始化 → 执行静态代码块，导致无限循环，最终栈溢出。

面试官：最后一个问题！如果我有一个类，里面有一个静态变量被初始化为一个复杂对象，而这个对象的构造方法中又访问了另一个静态变量，会发生什么？

你的回答 ：这可能会导致未定义行为或抛出ExceptionInInitializerError。原因是静态变量的初始化是按代码顺序执行的。如果复杂对象的构造方法访问了一个尚未初始化的静态变量，该变量会返回默认值（例如null或0）。如果代码逻辑依赖于未初始化的变量值，可能导致逻辑错误或异常。因此，建议在静态初始化时避免复杂的依赖关系，尽量保持初始化逻辑简单。

面试官：非常好！你的回答很全面，对Java类加载顺序的理解很到位。谢谢！

三、总结

Java类加载顺序是一个核心知识点，理解其规则有助于编写更健壮的代码并应对复杂场景。以下是关键点总结：

静态资源（变量和代码块）在类初始化时执行一次，按代码顺序。
普通资源（变量和代码块）在对象创建时执行，每次创建都会执行。
构造方法在对象创建时调用，子类会先调用父类构造方法。
静态方法和普通方法需显式调用，不会自动执行。
避免在静态初始化中引入复杂依赖，以防未定义行为或异常。

通过以上示例代码和面试模拟，相信你已经对Java类加载顺序有了深入理解。如果有更多问题，欢迎继续探讨！