Instance Initialization Block (IIB) in Java

Instance Initialization Blocks or IIB are used to initialize instance variables. IIBs are executed before constructors. They run each time when object of the class is created.

• Initialization blocks are executed whenever the class is initialized
  and before constructors are invoked.
• They are typically placed above the constructors within braces.
• It is not at all necessary to include them in your classes.

// Java program to illustrate 
// Instance Initialization Block 
class GfG 
{ 
	// Instance Initialization Block 
	{ 
		System.out.println("IIB block"); 
	} 
	
	// Constructor of GfG class 
	GfG() 
	{ 
		System.out.println("Constructor Called"); 
	} 
	public static void main(String[] args) 
	{ 
		GfG a = new GfG(); 
	} 
} 

IIB block
Constructor Called

Multiple Instance Initialization Blocks in a Program

We can also have multiple IIBs in a single class. If compiler finds multiple IIBs, then they all are executed from top to bottom i.e. the IIB which is written at top will be executed first.

// Java program to illustrate 
// execution of multiple 
// Instance Initialization Blocks 
// in one program 
class GfG 
{ 
	// Instance Initialization Block - 1 
	{ 
		System.out.println("IIB1 block"); 
	} 
	
	// Instance Initialization Block - 2 
	{ 
		System.out.println("IIB2 block"); 
	} 
	
	// Constructor of class GfG 
	GfG() 
	{ 
		System.out.println("Constructor Called"); 
	} 
	
	// Instance Initialization Block - 3 
	{ 
		System.out.println("IIB3 block"); 
	} 
	
	// main function 
	public static void main(String[] args) 
	{ 
		GfG a = new GfG(); 
	} 
} 

Output :

IIB1 block
IIB2 block
IIB3 block
Constructor Called

Instance Initialization Block with parent class

You can have IIBs in parent class also. Instance initialization block code runs immediately after the call to super() in a constructor. The compiler executes parents class’s IIB before executing current class’s IIBs. Have a look on following example.

// Java program to illustrate 
// Instance Initialization Block 
// with super() 

// Parent Class 
class B 
{ 
	B() 
	{ 
		System.out.println("B-Constructor Called"); 
	} 

	{ 
		System.out.println("B-IIB block"); 
	} 

} 

// Child class 
class A extends B 
{ 
	A() 
	{ 
		super(); 
		System.out.println("A-Constructor Called"); 
	} 
	{ 
		System.out.println("A-IIB block"); 
	} 
	
	// main function 
	public static void main(String[] args) 
	{ 
		A a = new A(); 
	} 
} 

Output :

B-IIB block
B-Constructor Called
A-IIB block
A-Constructor Called

In above example, compiler tries to execute constructor of class A, when object of class A is created. But it finds super() statement and goes to the parent class constructor first to be executed. Order of execution in this case will be as follows:
I. Instance Initialization Block of super class
II. Constructors of super class
III. Instance Initialization Blocks of the class
IV. Constructors of the class

Important points:

Instance Initialization Blocks run every time a new instance is created.
Initialization Blocks run in the order they appear in the program
The Instance Initialization Block is invoked after the parent class constructor is invoked (i.e. after super() constructor call)