Order of Execution of Initialization Blocks and Constructors in Java

In Java, there are various techniques, which we can use to initialize and perform operations on objects such as methods, constructors, and initialization blocks. These tools are used to ensure that the program works as expected.

• Instance Initialization Blocks (IIB) are used to initialize instance variables. IIBs are executed before constructors. They run each time when object of the class is created.
• Initializer block contains the code that is always executed whenever an instance is created. It is used to declare/initialize the common part of various constructors of a class.
• Constructors are used to initialize the object’s state. Like methods, a constructor also contains a collection of statements(i.e., instructions) that are executed at the time of Object creation.

Prerequisite: Static blocks, Initializer block, Constructor

Execution Order of Initialization Blocks and Constructors in Java

• Static initialization blocks will run whenever the class is loaded first time in JVM.
• Initialization blocks run in the same order in which they appear in the program.
• Instance Initialization blocks are executed whenever the class is initialized and before constructors are invoked. They are typically placed above the constructors within braces.
• Constructors are called after all the instance initialization blocks

Note: If there are multiple static or Instance Initialization blocks then the execution will start in the same order in which they appear in the source code.

Example 1: In this example, we are demonstrating the execution sequence of static blocks, instance initialization blocks, and constructors when objects are created.

// Java program to demonstrate the order of 
// execution of constructors, static blocks, 
// and instance initialization blocks
class Geeks {
    Geeks(int x) {
        System.out.println("ONE argument constructor");
    }

    Geeks() {
        System.out.println("No argument constructor");
    }

    static {
        System.out.println("1st static init");
    }

    {
        System.out.println("1st instance init");
    }

    {
        System.out.println("2nd instance init");
    }

    static {
        System.out.println("2nd static init");
    }

    public static void main(String[] args) {
        new Geeks();
        new Geeks(8);
    }
}

1st static init
2nd static init
1st instance init
2nd instance init
No argument constructor
1st instance init
2nd instance init
ONE argument constructor

Explanation: Here, when the class is loaded, the static block will execute first. After that the instance initialization blocks are executed before the constructor everytime an object is created and then the constructor is called.

If there are two or more static/initializer blocks then they are executed in the order in which they appear in the source code. Now, predict the output of the following program.

Example 2: In this example, we are showing how the order of static initializations and field assignments can affect the program output in a non-obvious way.

// Java program to demonstrate tricky behavior 
// of static initialization blocks and their 
// order of execution
class MyTest {
    static {
        initialize();
    }

    private static int sum;

    public static int getSum() {
        initialize();
        return sum;
    }

    private static boolean initialized = false;

    private static void initialize() {
        if (!initialized) {
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            initialized = true;
        }
    }
}

public class Geeks {
    public static void main(String[] args) {
        System.out.println(MyTest.getSum());
    }
}

9900

Explanation:

• Loop in initialize function goes from 0 to 99. With that in mind, you might think that the program prints the sum of the numbers from 0 to 99. Thus sum is 99 × 100 / 2, or 4950. The program, however, thinks otherwise. It prints 9900, fully twice this value.
• To understand its behavior, let’s trace its execution.The GFG.main method invokes MyTest.getSum. Before the getSum method can be executed, the VM must initialize the class MyTest. Class initialization executes static initializers in the order they appear in the source.
• The MyTest class has two static initializers: the static block at the top of the class and the initialization of the static field initialized. The block appears first. It invokes the method initialize, which tests the field initialized. Because no value has been assigned to this field, it has the default boolean value of false.
• Similarly, sum has the default int value of 0. Therefore, the initialize method does what you’d expect, adding 4, 950 to sum and setting initialized to true. After the static block executes, the static initializer for the initialized field sets it back to false, completing the class initialization of MyTest. Unfortunately, sum now contains the 4950, but initialized contains false.
• The main method in the GFG class then invokes MyTest.getSum, which in turn invokes initialize method. Because the initialized flag is false, the initializeIf method enters its loop, which adds another 4, 950 to the value of sum, increasing its value to 9, 900. The getSum method returns this value, and the program prints it.