Java中调用静态字段new时的初始化顺序问题

Hey there! Let's unpack this confusion—Java's class initialization rules are super specific, so it's easy to hit a case where things don't behave exactly like you expect. First, let's recap the JavaDoc rule you mentioned to make sure we're on the same page:

类的初始化包括执行其静态初始化器和类中声明的静态字段（类变量）的初始化器，类或接口类型T会在以下任一首次出现前立即初始化：

• T是类且创建了T的实例
• 调用了T声明的静态方法
• 给T声明的静态字段赋值
• 使用了T声明的静态字段，且该字段不是常量变量
• T是顶级类，且执行了在T中词法嵌套的assert语句

Now, the most common reason your A3 static block isn't running before the constructor is that your code isn't actually triggering A3's initialization before the constructor runs—or in some cases, the initialization is happening but you're misinterpreting the output order. Let's walk through a few typical scenarios that cause this:

Scenario 1: You're accessing a compile-time constant from A3 #

If your code references a static final field that's a compile-time constant (like a string literal or primitive value), the compiler replaces the field reference with the actual constant value at compile time. That means the JVM never needs to initialize A3 to get the value, so the static block never runs. Example:

class A3 {
    public static final String FIXED_VALUE = "I'm a constant";
    static {
        System.out.println("A3 static block executed");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(A3.FIXED_VALUE); // 不会触发A3的初始化
    }
}

Scenario 2: You're misordering parent vs child initialization output #

If A3 extends a parent class, the initialization order might look counterintuitive at first. Let's take this hierarchy:

class A1 {
    public A1() {
        System.out.println("A1 constructor running");
    }
}

class A3 extends A1 {
    static {
        System.out.println("A3 static block executed");
    }

    public A3() {
        System.out.println("A3 constructor running");
    }
}

public class Test {
    public static void main(String[] args) {
        new A3();
    }
}

The actual output order is:

1. A3 static block executed
2. A1 constructor running
3. A3 constructor running

If you expected the static block to run between the parent and child constructor, that's not how it works. Class initialization (static block) runs once when the class is first loaded, before any instance is created. The parent constructor runs as part of the child instance creation process, but after the child class is fully initialized.

Scenario 3: You're not hitting any initialization triggers #

If your code only references A3 as a type (like declaring A3 a; but never instantiating it, or using it as a generic parameter), the JVM won't initialize A3. Initialization only happens when one of the JavaDoc-defined triggers is hit.

Quick way to test #

Add a static method call or static field assignment for A3 before instantiating it—you'll see the static block run immediately:

public class Test {
    public static void main(String[] args) {
        A3.someStaticMethod(); // 触发A3初始化
        new A3();
    }
}

The key takeaway here is that Java's class initialization is lazy—it only happens when absolutely necessary, as defined by those specific triggers. If your expected output doesn't match, double-check which triggers are being hit in your code.

内容的提问来源于stack exchange，提问作者zrilman