When a class has multiple static initializer blocks and static field initializers interleaved, in what order do they execute?

## The core rule: textual order, one merged sequence A class body can contain both **static field initializers** (`static int a = 1;`) and **static initializer blocks** (`static { ... }`). It's tempting to think Java runs all field initializers first and then all blocks — it does **not**. Instead, the compiler/JVM collects every static initializer (field-assignment *and* block) into **one sequence, in the exact order they appear in the source file**, and executes that sequence top to bottom during class initialization. Each runs exactly once. ```java class Demo { static int a = 1; // (1) static { System.out.println(a); } // (2) prints 1 — a already set above static int b = a + 10; // (3) b = 11 static { System.out.println(b); } // (4) prints 11 } // Output when Demo is initialized: 1 then 11 ``` ## Why ordering matters: reading a not-yet-initialized field Because execution is strictly top-down, a static block can only safely **read** static fields **declared above it**. A field declared *below* still holds its **default value** (0 for numbers, `false` for boolean, `null` for references) when an earlier block runs: ```java class Trap { static { System.out.println(x); } // prints 0 — x not yet initialized static int x = 42; } ``` This is a frequent interview trap and a real-world bug source. The fix is to declare/initialize the field *before* the block that needs it. ## The forward-reference subtlety: write is allowed, read is not Java's 'illegal forward reference' rule restricts *reading* a static field before its textual declaration, but **assignment** to it is permitted. So this compiles: ```java class FwdWrite { static { y = 5; } // legal: writing y before its declaration static int y; // y ends up 5 if no later initializer overwrites it } ``` Note that if the field also has an inline initializer below, that initializer runs *after* the block (textual order) and would overwrite the block's write. ## Inheritance: superclass before subclass When a subclass is initialized, the JVM guarantees the **superclass is fully initialized first**. So the order across a hierarchy is: superclass static initializers (in their textual order) → then subclass static initializers (in their textual order). Instance-level initialization (instance initializers + constructors) is a separate, later concern and runs per object. ## What does NOT change the order - Mixing field initializers and blocks freely — still strict textual order. - The number of blocks — three blocks run in their three positions. - Access modifiers or field types — irrelevant to ordering. ## Mental model to carry into an interview Think of the JVM as flattening the class's static parts into one script, line by line, and executing it once. 'Can this block see that field?' → 'Is the field's initialization line *above* this block?' If yes, it's the real value; if no, it's the default (for reads) — and writing ahead is the only forward operation allowed.