Java Instance Initializer Block Tutorial with Examples

In Java, an Instance Initializer Block (IIB) is a block of code that is executed whenever an object of the class is created.

It allows us to initialize instance variables or perform actions that need to be executed each time a new object is instantiated, regardless of the constructor used.

The block runs before the constructor and after instance variables are initialized.

In this tutorial, we will cover:

1. What is an Instance Initializer Block?
2. Basic Syntax of Instance Initializer Block
3. Why Use Instance Initializer Blocks?
4. Order of Execution: IIB vs Constructor
5. Multiple Instance Initializer Blocks
6. Examples and Use Cases

Let’s explore each concept with examples!

1. What is an Instance Initializer Block?

An Instance Initializer Block (IIB) is a block of code enclosed in curly braces {} that is executed before the constructor and is used to initialize instance variables or perform any initialization logic. It gets executed every time an object is created.

Key Characteristics:

• It is executed before the constructor.
• It can be used for shared initialization among constructors.
• It runs each time an instance is created.

2. Basic Syntax of Instance Initializer Block

The syntax for an Instance Initializer Block is straightforward. You simply define a block of code with curly braces {} outside any methods or constructors in the class.

Example 1: Basic Instance Initializer Block

class Example {
    // Instance variable
    int value;

    // Instance Initializer Block
    {
        value = 10;
        System.out.println("Instance Initializer Block executed, value set to " + value);
    }

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

public class InstanceInitializerExample {
    public static void main(String[] args) {
        Example obj = new Example();
        // Output:
        // Instance Initializer Block executed, value set to 10
        // Constructor executed.
    }
}

Explanation:

• The Instance Initializer Block sets the value of the value variable to 10.
• The block is executed before the constructor, and the constructor is executed afterward.

3. Why Use Instance Initializer Blocks?

Instance Initializer Blocks are useful when:

• Multiple constructors share common initialization code. Instead of duplicating the initialization logic in each constructor, you can put it in an IIB.
• You need to perform complex initialization that can’t be done in field initializations or constructor parameters.
• You want to ensure certain code is always executed, regardless of which constructor is used.

Example 2: Shared Initialization Code Across Constructors

class Initialization {
    int a;
    int b;

    // Instance Initializer Block
    {
        a = 5;
        b = 10;
        System.out.println("Instance Initializer Block executed: a = " + a + ", b = " + b);
    }

    // Constructor 1
    public Initialization() {
        System.out.println("Default constructor called.");
    }

    // Constructor 2
    public Initialization(int b) {
        this.b = b;
        System.out.println("Parameterized constructor called. b = " + b);
    }
}

public class InitializationExample {
    public static void main(String[] args) {
        Initialization obj1 = new Initialization();
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Default constructor called.

        Initialization obj2 = new Initialization(20);
        // Output:
        // Instance Initializer Block executed: a = 5, b = 10
        // Parameterized constructor called. b = 20
    }
}

Explanation:

• The IIB initializes the values of a and b. Both constructors use this shared initialization logic, ensuring that the values are properly set before the constructor logic is executed.

4. Order of Execution: IIB vs Constructor

Instance Initializer Blocks are executed before the constructor but after the instance variables are initialized. The IIB can modify instance variables before the constructor is executed.

Example 3: Execution Order of IIB and Constructor

class ExecutionOrder {
    // Instance variable
    int x = 100;

    // Instance Initializer Block
    {
        System.out.println("IIB executed. Initial value of x = " + x);
        x = 200;  // Modifying the value of x
    }

    // Constructor
    public ExecutionOrder() {
        System.out.println("Constructor executed. Final value of x = " + x);
    }
}

public class ExecutionOrderExample {
    public static void main(String[] args) {
        ExecutionOrder obj = new ExecutionOrder();
        // Output:
        // IIB executed. Initial value of x = 100
        // Constructor executed. Final value of x = 200
    }
}

Explanation:

• First, the instance variable x is initialized to 100.
• The IIB modifies the value of x to 200.
• The constructor is then executed after the IIB, with the final value of x being 200.

5. Multiple Instance Initializer Blocks

You can have multiple Instance Initializer Blocks in a class. They will be executed in the order in which they appear in the class, from top to bottom.

Example 4: Multiple Instance Initializer Blocks

class MultipleIIB {
    int x;
    int y;

    // First Instance Initializer Block
    {
        x = 5;
        System.out.println("First IIB executed: x = " + x);
    }

    // Second Instance Initializer Block
    {
        y = 10;
        System.out.println("Second IIB executed: y = " + y);
    }

    // Constructor
    public MultipleIIB() {
        System.out.println("Constructor executed: x = " + x + ", y = " + y);
    }
}

public class MultipleIIBExample {
    public static void main(String[] args) {
        MultipleIIB obj = new MultipleIIB();
        // Output:
        // First IIB executed: x = 5
        // Second IIB executed: y = 10
        // Constructor executed: x = 5, y = 10
    }
}

Explanation:

• The first IIB is executed before the second IIB, which means x is initialized before y.
• After both IIBs have executed, the constructor is called to finalize the object creation.

6. Examples and Use Cases

Example 5: Instance Initializer Block for Resource Initialization

Sometimes, you may want to initialize resources or perform setup actions every time an object is created.

class ResourceInitialization {
    // Instance variable
    String resource;

    // Instance Initializer Block
    {
        System.out.println("Initializing resource...");
        resource = "Database Connection";
    }

    // Constructor
    public ResourceInitialization() {
        System.out.println("Constructor: Resource initialized as " + resource);
    }
}

public class ResourceInitializationExample {
    public static void main(String[] args) {
        ResourceInitialization obj = new ResourceInitialization();
        // Output:
        // Initializing resource...
        // Constructor: Resource initialized as Database Connection
    }
}

Explanation:

• The IIB simulates resource initialization (such as opening a database connection) every time an object is created.
• The constructor then completes the object creation process.

Example 6: Instance Initializer Blocks in Inheritance

When a class extends another class, both the parent and child class can have Instance Initializer Blocks.

class Parent {
    {
        System.out.println("Parent IIB executed.");
    }

    public Parent() {
        System.out.println("Parent constructor executed.");
    }
}

class Child extends Parent {
    {
        System.out.println("Child IIB executed.");
    }

    public Child() {
        System.out.println("Child constructor executed.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Child obj = new Child();
        // Output:
        // Parent IIB executed.
        // Parent constructor executed.
        // Child IIB executed.
        // Child constructor executed.
    }
}

Explanation:

• The IIB in the parent class runs before the IIB in the child class.
• The constructor in the parent class is executed before the child class constructor, demonstrating the order of execution.

Summary of Key Concepts for Instance Initializer Blocks

Conclusion

In Java, Instance Initializer Blocks (IIBs) are a powerful tool for handling common initialization logic. In this tutorial, we covered:

• The basic syntax of Instance Initializer Blocks and how they are executed.
• Why and when to use IIBs, especially for shared initialization across constructors.
• The order of execution between instance initializer blocks and constructors.
• How to use multiple IIBs and their role in inheritance.