How Do Instance and Static Initializer Blocks Run?

The order is fixed by the language specification and it is worth being able to recite it. For a class, the static parts run once: the static field declarations and static initializer blocks execute in the order they appear in the source, when the class is initialised. The class is initialised lazily, at first active use — the first time you construct an instance, or the first time you touch a static member that requires the class to be prepared.

For each object, the instance parts run in this order. First the instance field initialisers and instance initializer blocks, interleaved in source order. Then the body of the constructor. And that whole sequence happens after the superclass constructor has completed, because the superclass must be fully built before the subclass constructor body runs.

public class Main {
    public static void main(String[] args) {
        System.out.println("--- touching Counter.MAX triggers class init ---");
        int max = Counter.MAX;
        System.out.println("Counter.MAX = " + max);

        System.out.println("--- first instance ---");
        Counter first = new Counter();
        System.out.println("first.id  = " + first.id);

        System.out.println("--- second instance ---");
        Counter second = new Counter();
        System.out.println("second.id = " + second.id);
        System.out.println("instances = " + Counter.instances);
    }
}

class Counter {
    static final int MAX = 100;
    static int instances = 0;

    static {
        System.out.println("static initializer block");
    }

    final int id;

    {
        // Instance initializer: runs before every constructor body.
        id = ++instances;
        System.out.println("instance initializer, id=" + id);
    }

    Counter() {
        System.out.println("constructor body");
    }
}

The output walks through the whole sequence. The static initializer block runs the first time the class is touched, before the first instance exists. Then for each object the instance initializer runs before the constructor body, and the second instance sees the counter continue from one to two because the static field was never reset.

Two details the output makes clear. The static block ran when Counter.MAX was read, not when the class was loaded — class loading and class initialisation are separate steps. And the instance initializer runs for every instance, not once for the class.

They run first because of how object construction is specified. The instance initialisers and initializer blocks are part of the instance initialisation phase, and that phase completes before the constructor body executes. The reason is the blank final field rule: a blank final must be definitely assigned by the end of the constructor, and the compiler's definite-assignment analysis treats the instance initialisers as part of the assignment sequence. Doing them first also means the constructor body always sees fully initialised fields, whatever order the fields are declared in.

The problem is not the mechanism but the readability cost. An instance initializer block is invisible to a reader scanning the class for initialisation logic — it sits between the field declarations and the constructor, with no name and no signature, and it runs for every constructor including any that delegate. When a class has several constructors, the block's effect applies to all of them, which makes the flow of initialisation hard to follow.

There is also a subtler hazard. Because the block runs before the constructor body, it cannot see anything the constructor computes. If a field is assigned in the block and then reassigned in the constructor, the block's work is wasted, and if the block throws, the object never reaches the constructor at all — so a failure there surfaces at a completely unexpected place.

public class Main {
    public static void main(String[] args) {
        // The instance initializer runs before the constructor body.
        Config first = new Config("prod");
        System.out.println("name   : " + first.name());
        System.out.println("source : " + first.source());

        // The block runs for every instance, not just the first.
        Config second = new Config("staging");
        System.out.println("name   : " + second.name());
        System.out.println("source : " + second.source());
    }
}

class Config {
    private final String name;
    private final String source;

    static {
        System.out.println("static initializer ran");
    }

    {
        // Runs for every instance, before the constructor body.
        source = "defaults";
        System.out.println("instance initializer ran");
    }

    Config(String name) {
        this.name = name;
        System.out.println("constructor body ran");
    }

    String name() {
        return name;
    }

    String source() {
        return source;
    }
}

The practical guidance is to put instance initialisation in the constructor, where it is visible and where you can order it deliberately, and to use a static initializer block only for the genuinely one-time, genuinely static work that a static field declaration cannot express.

The order is visible in the output — the instance initializer runs before the constructor body, and the static initializer runs once when the class is first loaded:

A static initializer block is a block of code that runs once, when the class is initialised, before any instance of that class is created. It is written as a bare static { ... } block with no name and no access modifier.

It exists for the things a static field declaration cannot express. A field declaration with an initialiser can only assign a constant or the result of an expression; it cannot contain statements, it cannot run a loop, and it cannot handle failure. A static block can do all of that. The typical uses are loading a configuration file, opening a resource once and holding it in a static field, registering a driver, or populating a static lookup map with more than one entry.

The difference in execution is also real. A static field with an initialiser is compiled into the class initialisation routine and runs when the class is initialised. A static block runs at exactly the same moment, in source order relative to the other static field declarations. So the two are not different in when they run — only in what they can contain.

Two cautions. A static block that throws wraps the exception in an ExceptionInInitializerError, and every later use of that class then fails with NoClassDefFoundError, which is a confusing way to discover a bad configuration file. And a static block that blocks — opening a network connection, say — holds a class-initialisation lock that every other thread touching that class must wait on, which is how a slow start-up becomes a production incident.