Instance Initializer Block

When Instance Initializer Blocks Run

Java performs object construction in a strict order: first, if this class has a superclass, the superclass's constructor chain runs completely (via the implicit or explicit super(...) call). Then, within this class, instance variable initializers and instance initializer blocks run in the exact top-to-bottom order they appear in the source file. Only after all of that completes does the remaining code in this class's constructor body run.

• Superclass constructor (always runs first, even if implicit).
• Instance variable initializers and instance initializer blocks, in source order.
• The rest of the current constructor's body.

How the Compiler Copies the Block into Every Constructor

An instance block is not a separate method that the JVM calls. When javac compiles the class, it copies the code of every field initializer and instance block into each constructor, placing it immediately after the super(...) call and before the constructor's own statements. That is why the block always runs after the parent is built but before your constructor body, and why it runs no matter which constructor was used. If a class has no constructor, the block goes into the default constructor the compiler generates.

Multiple Blocks and Field Initializers: Textual Order Matters

A class may contain any number of instance blocks. They run from top to bottom, interleaved with field initializers (int x = 10;) in exactly the order they are written. So a block can see a field assigned above it, and a field initializer below a block sees whatever the block set. The reverse is restricted: a block that reads a field declared further down, by its simple name, fails to compile with illegal forward reference. Keep fields at the top and blocks after them, and the order stays easy to follow.

Instance Blocks and this() Constructor Chaining

The copied block code goes only into constructors that call super(...), either explicitly or implicitly. A constructor that starts with this(...) does not get a copy, because it hands off to another constructor of the same class, and that one will run the block. The result is that the block runs exactly once per object, even when constructors chain into each other.

Execution Order with Inheritance

With a parent and a child class, Java first initialises the classes and then builds the object from the top of the hierarchy down.

• Parent static blocks, then child static blocks — once, the first time the class is used.
• For every object: the parent's field initializers and instance blocks, then the parent's constructor body.
• Then the child's field initializers and instance blocks, then the child's constructor body.
• Creating a second object repeats only the per-object steps; static blocks do not run again.

Why Use an Instance Initializer Block

Instance initializer blocks are most useful when a class has multiple overloaded constructors that all need to share some common initialization logic that is too involved for a simple field initializer expression — placing that shared logic in an IIB guarantees it runs no matter which constructor is used, without duplicating code in every constructor. In modern Java, this pattern is relatively uncommon since constructor chaining with this(...) usually achieves the same goal more explicitly, but it still appears in anonymous class initialization and in legacy codebases.

Instance Block vs Static Block

A static block runs exactly once per class, at class-loading time, before any object exists. An instance initializer block runs once per object creation, every time new is used, right before the constructor body — meaning if you create five objects, the instance block runs five times, but a static block in the same class would have already run only once, earlier, at class load.

• Syntax: static { ... } vs plain { ... }.
• Runs: once per class vs once per object.
• When: during class initialisation vs during new, after super(...) and before the constructor body.
• Can use: only static members vs both static and instance members, including this.
• Typical job: set up static data such as a lookup table vs common setup for every object.
• Full order for one new object of a class used for the first time: static block, then instance block, then constructor.

Rules and Limits

• An instance block may throw a checked exception only if every constructor of the class declares it in its throws clause. A block that can never finish normally (it always throws) is rejected with initializer must be able to complete normally.
• It cannot contain a return statement; javac reports return outside method.
• It can use this, instance fields and instance methods, because the object already exists when it runs.
• Code in it cannot take arguments, so anything that depends on constructor parameters must stay in the constructor.

Examples

public class InitDemo {
    static {
        System.out.println("Static block (runs once, at class load)");
    }

    {
        System.out.println("Instance initializer block (runs before each constructor)");
    }

    InitDemo() {
        System.out.println("Constructor body");
    }

    public static void main(String[] args) {
        System.out.println("Creating first object:");
        new InitDemo();
        System.out.println("Creating second object:");
        new InitDemo();
    }
}

Static block (runs once, at class load)
Creating first object:
Instance initializer block (runs before each constructor)
Constructor body
Creating second object:
Instance initializer block (runs before each constructor)
Constructor body

public class OrderDemo {
    int x = 10;                 // 1. field initializer

    {
        System.out.println("Block 1: x = " + x);
        x = 20;                 // 2. first instance block
    }

    int y = x + 1;              // 3. sees x = 20

    {
        System.out.println("Block 2: y = " + y);  // 4. second instance block
    }

    OrderDemo() {
        System.out.println("Constructor: x = " + x + ", y = " + y);
    }

    public static void main(String[] args) {
        new OrderDemo();
    }
}

Block 1: x = 10
Block 2: y = 21
Constructor: x = 20, y = 21

public class ChainDemo {
    {
        System.out.println("instance block");
    }

    ChainDemo() {
        this("guest");          // delegates: the block is NOT copied here
        System.out.println("no-arg constructor");
    }

    ChainDemo(String user) {    // calls super() implicitly: the block runs here
        System.out.println("constructor for " + user);
    }

    public static void main(String[] args) {
        new ChainDemo();
        System.out.println("---");
        new ChainDemo("admin");
    }
}

instance block
constructor for guest
no-arg constructor
---
instance block
constructor for admin

public class InheritDemo {
    public static void main(String[] args) {
        new Child();
        System.out.println("---");
        new Child();
    }
}

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

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

1. Parent static block
2. Child static block
3. Parent instance block
4. Parent constructor
5. Child instance block
6. Child constructor
---
3. Parent instance block
4. Parent constructor
5. Child instance block
6. Child constructor

import java.util.ArrayList;
import java.util.List;

public class AnonDemo {
    public static void main(String[] args) {
        // An anonymous class cannot declare a constructor, so setup goes in an instance block
        List<String> langs = new ArrayList<>() {
            {
                add("Java");
                add("Python");
            }
        };
        System.out.println(langs);
    }
}

[Java, Python]

Exercise

Add a static block, an instance initializer block and a constructor to Session, each printing one word, so that creating two objects produces the output below.

Expected output: static, instance, constructor, instance, constructor, each on its own line.

class Session {
    // TODO: a static block that prints "static"
    // TODO: an instance initializer block that prints "instance"
    // TODO: a constructor that prints "constructor"
}

public class SessionDemo {
    public static void main(String[] args) {
        new Session();
        new Session();
    }
}

class Session {
    static {
        System.out.println("static");
    }

    {
        System.out.println("instance");
    }

    Session() {
        System.out.println("constructor");
    }
}

public class SessionDemo {
    public static void main(String[] args) {
        new Session();
        new Session();
    }
}

Quick quiz

Interview questions

Go deeper

• Static Keyword (static blocks)
• Constructors and Constructor Overloading
• super Keyword (constructor chaining)