Why Do We Need Instance Initialization Blocks (IIB) If We Have Constructors?
Instance Initialization Blocks (IIB) are not strictly necessary, but they provide some benefits over constructors in certain cases. Here’s why:
1. To Avoid Code Duplication in Multiple Constructors
If a class has multiple constructors, an instance block helps initialize common fields without repeating code in each constructor.
Example Without Instance Block (Code Duplication)
class Example {
int x, y;
Example() {
// Common initialization
x = 10;
y = 20;
System.out.println("Default Constructor");
}
Example(int a) {
// Same initialization repeated
x = 10;
y = 20;
System.out.println("Parameterized Constructor: " + a);
}
void display() {
System.out.println("x: " + x + ", y: " + y);
}
public static void main(String[] args) {
new Example().display();
new Example(5).display();
}
}
Problem
- The initialization code (
x = 10; y = 20;
) is duplicated in both constructors. - If we need to modify initialization logic, we must update every constructor.
Example Using an Instance Block (Avoids Duplication)
class Example {
int x, y;
// Instance Initialization Block (runs before any constructor)
{
x = 10;
y = 20;
System.out.println("Instance Block Executed");
}
Example() {
System.out.println("Default Constructor");
}
Example(int a) {
System.out.println("Parameterized Constructor: " + a);
}
void display() {
System.out.println("x: " + x + ", y: " + y);
}
public static void main(String[] args) {
new Example().display();
new Example(5).display();
}
}
Output
Instance Block Executed
Default Constructor
x: 10, y: 20
Instance Block Executed
Parameterized Constructor: 5
x: 10, y: 20
✔ The initialization code is written only once in the instance block.
✔ Instance block executes before each constructor, ensuring x
and y
are always initialized.
2. Runs Before Constructors, Even If Constructor Calls super()
- When a constructor calls
super()
, the superclass constructor runs before the subclass constructor. - However, instance blocks in the subclass execute before its constructor, ensuring initialization happens before constructor execution.
Example
class Parent {
Parent() {
System.out.println("Parent Constructor");
}
}
class Child extends Parent {
int x;
// Instance block runs **before** Child's constructor
{
x = 100;
System.out.println("Instance Block in Child");
}
Child() {
System.out.println("Child Constructor");
}
public static void main(String[] args) {
new Child();
}
}
Output
Parent Constructor
Instance Block in Child
Child Constructor
✔ Even though super()
runs first, the instance block runs before the Child constructor.
✔ This ensures that instance variables in Child
are initialized before the constructor executes.
3. Useful for Complex Object Initialization
If object initialization requires multiple steps or conditions, an instance block can help simplify the process.
Example: Initializing an Array in an Instance Block
class Example {
int[] numbers;
// Instance block initializes the array
{
numbers = new int[5];
for (int i = 0; i < numbers.length; i++) {
numbers[i] = i * 10;
}
System.out.println("Instance Block: Array Initialized");
}
Example() {
System.out.println("Constructor Called");
}
void display() {
for (int num : numbers) {
System.out.print(num + " ");
}
System.out.println();
}
public static void main(String[] args) {
new Example().display();
}
}
Output
Instance Block: Array Initialized
Constructor Called
0 10 20 30 40
✔ The instance block ensures the array is initialized properly before the constructor runs.
Final Thoughts
Feature | Instance Block | Constructor |
---|---|---|
Runs before constructor? | ✅ Yes | ❌ No |
Reduces code duplication? | ✅ Yes | ❌ No (if multiple constructors exist) |
Handles common initialization? | ✅ Yes | ✅ Yes |
Runs every time an object is created? | ✅ Yes | ✅ Yes |
Used in inheritance before constructor? | ✅ Yes | ❌ No |
When to Use Instance Blocks?
✔ If you have common initialization logic across multiple constructors.
✔ If initialization must happen before the constructor runs.
✔ If the constructor calls super()
, but you need subclass fields initialized first.
✔ If initialization is complex (e.g., setting up arrays, collections, or dependent values).