Detailed Explanation of Class Initialization Process and Order in Java

I. Basic Concepts of Class Initialization Process
Class initialization is the final stage of the class loading process, which involves assigning program-defined initial values to static variables of the class and executing static code blocks. During this stage, the class constructor <clinit>() method is executed. This method is automatically generated by the compiler by merging all static variable assignment actions and static code blocks from the class.

II. Triggers for Class Initialization Process

1. Creating an instance of a class (using the new keyword)
2. Accessing a static variable (non-constant) or static method of a class
3. Using reflection to call class methods
4. Initializing a subclass of a class (triggers parent class initialization first)
5. The main class specified when the JVM starts

III. Specific Steps of Class Initialization Process
Let's understand the complete initialization order through a concrete example:

class Parent {
    // 1. Parent static variable
    static String staticField = "Parent Static Variable";
    
    // 2. Parent static block
    static {
        System.out.println(staticField);
        System.out.println("Parent Static Block");
    }
    
    // 5. Parent instance variable
    String instanceField = "Parent Instance Variable";
    
    // 6. Parent instance block
    {
        System.out.println(instanceField);
        System.out.println("Parent Instance Block");
    }
    
    // 7. Parent constructor
    public Parent() {
        System.out.println("Parent Constructor");
    }
}

class Child extends Parent {
    // 3. Child static variable
    static String staticField = "Child Static Variable";
    
    // 4. Child static block
    static {
        System.out.println(staticField);
        System.out.println("Child Static Block");
    }
    
    // 8. Child instance variable
    String instanceField = "Child Instance Variable";
    
    // 9. Child instance block
    {
        System.out.println(instanceField);
        System.out.println("Child Instance Block");
    }
    
    // 10. Child constructor
    public Child() {
        System.out.println("Child Constructor");
    }
}

IV. Analysis of Initialization Process Execution Order
When executing new Child(), the initialization order is as follows:

1. Parent Static Member Initialization: Parent class static variable assignment and static block execution

   • Output: "Parent Static Variable"
   • Output: "Parent Static Block"

2. Child Static Member Initialization: Child class static variable assignment and static block execution

   • Output: "Child Static Variable"
   • Output: "Child Static Block"

3. Parent Instance Member Initialization: Parent class instance variable assignment and instance block execution

   • Output: "Parent Instance Variable"
   • Output: "Parent Instance Block"

4. Parent Constructor Execution: Code in parent class constructor

   • Output: "Parent Constructor"

5. Child Instance Member Initialization: Child class instance variable assignment and instance block execution

   • Output: "Child Instance Variable"
   • Output: "Child Instance Block"

6. Child Constructor Execution: Code in child class constructor

   • Output: "Child Constructor"

V. Special Cases Analysis

1. Final Static Constants: Static constants modified by final that can be determined at compile time do not trigger class initialization

   class ConstantClass {
       static final String CONSTANT = "Constant Value";  // Does NOT trigger initialization
       static String variable = "Variable Value";        // DOES trigger initialization
   }
   

2. Interface Initialization: When an interface's <clinit>() method executes, it does NOT first execute the parent interface's <clinit>() method

3. Multithreading Environment: The JVM ensures the class's <clinit>() method is properly locked and synchronized in a multithreading environment

VI. Understanding from Memory Model Perspective
From the JMM perspective, the class initialization process establishes the following happens-before relationships:

• Class initialization happens-before any thread's use of that class
• Write operations to static variables happen-before subsequent read operations of the same static variables

VII. Practical Application Considerations

1. Avoid writing complex business logic in static blocks
2. Be aware of circular dependency issues: Mutual dependencies between static variables may cause initialization failure
3. Reasonably use lazy loading patterns to delay class initialization time

Understanding class initialization order is significant for avoiding NullPointerException, understanding the implementation principles of singleton patterns, and optimizing program startup performance.