Java Class Initialization Order: Understanding the Real Sequence

public class Example {
    // 1. Static fields initialized first
    private static int staticField = initializeStatic();
    
    // 2. Static blocks executed in order
    static {
        System.out.println("Static block 1");
    }
    
    static {
        System.out.println("Static block 2");
    }
    
    private static int initializeStatic() {
        System.out.println("Static field initialization");
        return 1;
    }
}

public class Example {
    // 3. Instance fields initialized
    private int instanceField = initializeInstance();
    
    // 4. Instance initialization blocks
    {
        System.out.println("Instance block");
    }
    
    // 5. Constructor executed last
    public Example() {
        System.out.println("Constructor");
    }
    
    private int initializeInstance() {
        System.out.println("Instance field initialization");
        return 1;
    }
}

public class InitializationDemo {
    // Step 1: Static fields
    private static String staticField = "Static field";
    
    // Step 2: Static blocks (in order)
    static {
        System.out.println("Static block 1");
    }
    
    static {
        System.out.println("Static block 2");
    }
    
    // Step 3: Instance fields
    private String instanceField = "Instance field";
    
    // Step 4: Instance blocks
    {
        System.out.println("Instance block");
    }
    
    // Step 5: Constructor
    public InitializationDemo() {
        System.out.println("Constructor");
    }
}

// Bad: Forward reference
public class BadExample {
    private int value = getValue(); // Error: forward reference
    private int multiplier = 10;
    
    private int getValue() {
        return multiplier * 2; // multiplier might not be initialized
    }
}

// Good: Initialize in correct order
public class GoodExample {
    private int multiplier = 10;
    private int value = getValue();
    
    private int getValue() {
        return multiplier * 2;
    }
}

public class ConfusingExample {
    private static int staticCounter = 0;
    private int instanceCounter = 0;
    
    static {
        staticCounter++;
        // Cannot access instanceCounter here!
    }
    
    {
        instanceCounter++;
        staticCounter++; // Can access static
    }
}

class Parent {
    static {
        System.out.println("Parent static block");
    }
    
    {
        System.out.println("Parent instance block");
    }
    
    public Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    static {
        System.out.println("Child static block");
    }
    
    {
        System.out.println("Child instance block");
    }
    
    public Child() {
        System.out.println("Child constructor");
    }
}

// Output order:
// Parent static block
// Child static block
// Parent instance block
// Parent constructor
// Child instance block
// Child constructor