Instance Initialization Block (IIB) in Java

Instance Initializer block is used to initialize the instance data member. It run each time when object of the class is created.

The initialization of the instance variable can be done directly but there can be performed extra operations while initializing the instance variable in the instance initializer block.

In a Java program, operations can be performed on methods, constructors and initialization blocks. 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(); } }


Output:
IIB block Constructor Called
Example of instance initializer block
class Bike7{ int speed; Bike7(){System.out.println("speed is "+speed);} {speed=150;} public static void main(String args[]){ Bike7 b1=new Bike7(); Bike7 b2=new Bike7(); } }


Output:
speed is 150 speed is 150
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.

class Cpr { // Instance Initialization Block - 1 { System.out.println("INDCPR1 block"); } // Instance Initialization Block - 2 { System.out.println("INDCPR2 block"); } // Constructor of class Cpr Cpr() { System.out.println("Constructor Called"); } // Instance Initialization Block - 3 { System.out.println("INDCPR3 block"); } // main function public static void main(String[] args) { Cpr a = new Cpr(); } }


Output:
INDCPR1 block INDCPR2 block INDCPR3 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.

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


Output:
B-CPR block B-Constructor Called A-CPR 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:

  1. Instance Initialization Block of super class

  2. Constructors of super class

  3. Instance Initialization Blocks of the class

  4. Constructors of the class

There are three places in java where you can perform operations:
  1. method
  2. constructor
  3. block
What is invoked first, instance initializer block or constructor?
class Bike8{ int speed; Bike8(){System.out.println("constructor is invoked");} {System.out.println("instance initializer block invoked");} public static void main(String args[]){ Bike8 b1=new Bike8(); Bike8 b2=new Bike8(); } }


Output:
instance initializer block invoked constructor is invoked instance initializer block invoked constructor is invoked
Rules for instance initializer block :

There are mainly three rules for the instance initializer block. They are as follows:

  1. The instance initializer block is created when instance of the class is created.

  2. The instance initializer block is invoked after the parent class constructor is invoked (i.e. after super() constructor call).

  3. The instance initializer block comes in the order in which they appear.

Program of instance initializer block that is invoked after super()
class A{ A(){ System.out.println("parent class constructor invoked"); } } class B2 extends A{ B2(){ super(); System.out.println("child class constructor invoked"); } {System.out.println("instance initializer block is invoked");} public static void main(String args[]){ B2 b=new B2(); } }


Output:
parent class constructor invoked instance initializer block is invoked child class constructor invoked
Another example of instance block
class A{ A(){ System.out.println("parent class constructor invoked"); } } class B3 extends A{ B3(){ super(); System.out.println("child class constructor invoked"); } B3(int a){ super(); System.out.println("child class constructor invoked "+a); } {System.out.println("instance initializer block is invoked");} public static void main(String args[]){ B3 b1=new B3(); B3 b2=new B3(31); } }


Output:
parent class constructor invoked instance initializer block is invoked child class constructor invoked parent class constructor invoked instance initializer block is invoked child class constructor invoked 10



Instagram