NUHMAN.com

Instance initialization blocks in Java are a powerful yet lesser-known feature that allow custom logic to run during object creation—between the superclass constructor call and the subclass constructor. This article explains their syntax, order of execution, use cases, and how they compare with constructors.

📦 What Is an Instance Initialization Block in Java?

Instance initialization blocks are code blocks defined inside a class that execute every time an object is created, after the superclass constructor but before the current class constructor.

🧱 Syntax

java

class MyClass {
    // Instance variable
    private int value;

    // Instance initialization block
    {
        value = 10;
        System.out.println("Instance initialization block executed");
    }

    // Constructor
    public MyClass() {
        System.out.println("Constructor executed");
    }

    public void displayValue() {
        System.out.println("Value: " + value);
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.displayValue();
    }
}

🔁 Order of Execution

1. Superclass constructor
2. Instance initialization block(s)
3. Constructor of the current class

🖨️ Output

makefile

Instance initialization block executed  
Constructor executed  
Value: 10

🧠 Key Points

• ✅ You can define multiple instance initialization blocks
• 📚 Blocks run in the order they appear
• 🧬 They execute before the class constructor
• 🧭 Can be useful in anonymous inner classes, where you can't define constructors
• 🔁 Can reduce code duplication across multiple constructors

⚡ Use Cases

✔️ Complex Shared Initialization

When multiple constructors need to run the same logic:

java

{
    // Shared logic
    System.out.println("Common init block");
}

✔️ Anonymous Inner Classes

Since constructors can't be defined in anonymous classes, instance blocks are a good alternative.

🧩 Multiple Instance Initialization Blocks Example

java

class MyClass {
    private int value1;
    private int value2;

    {
        value1 = 10;
        System.out.println("First instance initialization block executed");
    }

    {
        value2 = 20;
        System.out.println("Second instance initialization block executed");
    }

    public MyClass() {
        System.out.println("Constructor executed");
    }

    public void displayValues() {
        System.out.println("Value1: " + value1);
        System.out.println("Value2: " + value2);
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.displayValues();
    }
}

🖨️ Output

makefile

First instance initialization block executed  
Second instance initialization block executed  
Constructor executed  
Value1: 10  
Value2: 20

🧮 Constructor vs Instance Initialization Block

FeatureConstructorInstance Initialization BlockPlacementNamed method in classAnonymous block in class bodyExecutedDuring object creationBefore constructor during object creationPurposeInitialize object, run logicShared logic, reduce duplicationUse in Anonymous Class❌ Not allowed✅ Allowed

📌 Summary

Instance initialization blocks are a rarely used but valuable feature in Java for executing logic during object creation. They’re especially useful when:

• You want to avoid repeating code across constructors
• You need to initialize variables in anonymous classes
• You want better control over initialization order

By understanding how they work and when to use them, you can write cleaner and more maintainable Java code.