In what order do static blocks and initialization blocks execute when using inheritance?

Question

I have two classes Parent and Child

public class Parent {    
    public Parent() {
        System.out.println("Parent Constructor");
    }    
    static {
        System.out.println("Parent static block");    
    }    
    {
        System.out.println("Parent initialisation  block");
    }
}

public class Child extends Parent {    
    {
        System.out.println("Child initialisation block");
    }
    static {
        System.out.println("Child static block");
    }

    public Child() {
        System.out.println("Child Constructor");
    }    
    public static void main(String[] args) {
        new Child();    
    }
}

The output of the above code will be

Parent static block
Child static block
Parent initialization  block
Parent Constructor
Child initialization block
Child Constructor

Why does Java execute the code in that order? What are the rules that determine the execution order?

With the newer version of Java (1.7 and above), the JVM will throw a runtime exception as it does not find a main method in the class even though you have a static block. — lft93ryt, Jan 27 '17 at 16:46

Ky - · Answer 1 · 2020-04-28T19:32:08.263

I learn visually, so here's a visual representation of order, as a SSCCE:

public class Example {

    static {
        step(1);
    }

    public static int step_2 = step(2);
    public int step_8 = step(8);

    public Example(int unused) {
        super();
        step(10);
    }

    {
        step(9);
    }

    // Just for demonstration purposes:
    public static int step(int step) {
        System.out.println("Step " + step);
        return step;
    }
}

public class ExampleSubclass extends Example {

    {
        step(11);
    }

    public static int step_3 = step(3);
    public int step_12 = step(12);

    static {
        step(4);
    }

    public ExampleSubclass(int unused) {
        super(step(7));
        step(13);
    }

    public static void main(String[] args) {
        step(5);
        new ExampleSubclass(step(6));
        step(14);
    }
}

This prints:

Step 1
Step 2
Step 3
Step 4
Step 5
Step 6
Step 7
Step 8
Step 9
Step 10
Step 11
Step 12
Step 13
Step 14

Keep in mind that the order of the static parts matters; look back at the difference between the order of Example's static stuff and ExampleSubclass's.

Also note that the instance initialization block is always executed immediately after the super() call in the constructor (even if that call is implied/omitted), no matter the order. However, order does matter between an initialization block and a field initializer.

Please accompany any downvotes with a reason, so I know how to write better answers in the future :) — Ky -, Feb 02 '18 at 23:20
'The instance initialization block is always executed before the constructor': No it isn't, it is executed during the constructor, after the `super()` call. Your output doesn't disprove this. It executes before any lines of code in the cosntructo after `super()`. Not the same thing. — user207421, Apr 28 '20 at 07:10
Thank you for letting me know, @user207421. I'm having trouble visualizing what you're trying to say; when I place another `step()` call before `super()` in a constructor, I get these errors: https://photos.app.goo.gl/9ToHkTVuAutpjrbm7 - So I don't know how to test whether something happens before a `super()` call — Ky -, Apr 28 '20 at 19:16
Aha, I think I got it! I'll update my question. Thanks, @user207421! — Ky -, Apr 28 '20 at 19:28

score 61 · Answer 2 · edited Jun 20 '20 at 09:12

61

There are several rules in play

static blocks are always run before the object is created, so that's why you see print messages from both parents and child static blocks
now, when you are calling constructor of the subclass (child), then this constructor implicitly calls super(); before executing it's own constructor. Initialization block comes into play even before the constructor call, so that's why it is called first. So now your parent is created and the program can continue creating child class which will undergo the same process.

Explanations:

Static block of parent is executed first because it is loaded first and static blocks are called when the class is loaded.

edited Jun 20 '20 at 09:12

Community

1
1

answered Oct 24 '13 at 08:59

Petr Mensik

26,874
17
90
115

because the base class for the derived class is parent class created by you – Ankush Bist Jun 13 '16 at 07:38
Instance intialization blocks come into play *during* the constructor, after `super()` is executed. – user207421 Apr 28 '20 at 07:09

score 9 · Answer 3 · edited May 23 '17 at 12:03

First - run child class only (comment the extend clause) to see the simple flow.

second - go to Static block vs. initializer block in Java? & read the accepted answer over there.

Edit:

Execution happens in SIC way - Static, (non static) Initializer & Constructor.
(Non static) Initializer are copied into every constructor - At the TOP! (hence lines 3/4/5/6)
Before a class is initialized, its direct superclass must be initialized - http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4 (hence parent static block appears first).

score 9 · Answer 4 · edited Jun 21 '18 at 11:24

Static init blocks are executed at the time of class loading.
In the class hierarchy the order for execution of static init blocks will start from top level class.
In a class the order for the execution of static block is from top to bottom.
Above rule apply regardless of where the static block is present within the class.

(In your code the parent static blocks will be executed first and then the child class static blocks.)

Instance init blocks will be executed after the call to the super(); in the constructor.
- Always super(); is the very first statement in a default constructor.

In your code when you create a Child object:

The default constructor of the Child class get executed.
It will call to the super(); constructor.
Then the super class constructor is executed.
The Parent class will execute its super(); call.
After that the instance init blocks in the Parent class are executed.(From top to bottom).
Then the code within the constructor is executed (if any).
Then it will return to the Child class and execute the Child class instance init blocks.
Finally the code in the child constructor get executed (If exists).

Your second bullet point is correct, and your third bullet point contradicts it, so it is therefore incorrect. — user207421, Apr 28 '20 at 07:12
Good point: Instance initialization blocks will be executed after the call to the `super()` in the constructor. — Ray Jasson, Dec 20 '22 at 02:10

score 5 · Answer 5 · answered Oct 24 '13 at 09:05

Static block in java is executed before main method. If we declare a Static block in java class it is executed when class loads. This is initialize with the static variables. It is mostly used in JDBC. Static block in java is executed every time when a class loads. This is also known as Static initialization block. Static block in java initializes when class load into memory , it means when JVM read the byte code. Initialization can be anything; it can be variable initialization or anything else which should be shared by all objects of that class. Static block is a normal block of code enclosed in braces { } and is preceded by static keyword.

so static block executed first.

Instance Initialization Blocks: Runs every time when the instance of the class is created.

so next Initialization block executed when instance of the class is created.

then Constructor executed

why static block of parent class is executed first....?i am loading the child class first? — CKR666, Oct 24 '13 at 09:19
@CKR666 Loading the chld class requires loading its parents. It wouldn't make sense not to initialize the parent first. — user207421, Apr 28 '20 at 07:13

score 4 · Answer 6 · answered Mar 16 '17 at 13:16

Just wanted to share my findings. I read in one of the answers on another thread that static blocks are executed first before static fields which is not correct. It depends on which comes first, static field or static block. Have a look at below code. It will try to put things in perspective.

JVM looks for a class which has public static void main(String args[]) so that it can load that class.
It then initialises static fields of this class(if they come before static blocks). These fields can call static methods of this class or another. If they call static method of this class then that method gets served. If they call static method of another class, then static fields or blocks of that class(depending on which comes first) gets initialised first, then this method call is served.
Then, it moves to static blocks.

It comes back to main method.

class TestLab {
static int method(String a) {
    System.out.println("in static method of TestLab" + " Coming from " + a);
    System.out.println("b is " + b);
    return 6;
}

static int a = method("Line 11");
static int b = 7;

TestLab() {
    System.out.println("Inside test lab constructor");
}

static {
    System.out.println("In static block of TestLab");
}

}

public class Test1 {
public static void main(String[] args) {
    System.out.println("inside main method of Test 1");
    int a = TestLab.method("Line 26");
}

// static Test ref=new Test();
Test1() {
    System.out.println("Default Constructor of Test1");
}

{
    System.out.println("In instance block of Test1");
}
static int d = TestLab.method("Line 37");
static int e = methodOfTest1();
static {
    System.out.println("In Static Block of Test1");
}

static int methodOfTest1() {
    System.out.println("inside static method:mehtodOfTest1()");
    return 3;
}
}

Here is the output:

in static method of TestLab Coming from Line 11
b is 0
In static block of TestLab
in static method of TestLab Coming from Line 37
b is 7
inside static method:mehtodOfTest1()
In Static Block of Test1
inside main method of Test 1
in static method of TestLab Coming from Line 26
b is 7

You're contradicting yourself. Static fields and initializer blocks are executed in the order they appear in the source file, regardless of which is which. — user207421, Apr 28 '20 at 07:14
@user207421, I am sorry, I didn't get you. I have written the below which is what have been illustrated in the output: _It depends on which comes first, static field or static block_ — pragun, Dec 21 '20 at 18:52

score 3 · Answer 7 · answered Dec 10 '15 at 10:14

It would be very helpful to ckeck out the object construction process with a step by step debuger, having a view in which you can see how your object is goning through the phases. I found this very useful for clearing the perspective from a higher point of view. Eclipse can help you with this with it's debugger step into function.

score 2 · Answer 8 · answered Sep 14 '17 at 17:50

Here is what I found while preparing for a certification.

While we run a class, first static blocks/ static variable initialisation happens. If multiple static blocks are there, it will execute it in the order in which it appears,

Then it will execute init blocks/ instance variable initialisation.If multiple init blocks/ variable initialisation are there, it will execute it in the order in which it appears,

Afterwards it will look into the constructor.

score 1 · Answer 9 · answered Jul 16 '15 at 19:24

1

Static block gets executed when a class is loaded into JVM. While init block gets copied into the Constructor whose object will be created and runs before creation of object.

answered Jul 16 '15 at 19:24

Sunil Kumar Jha

841
1
8
11

score 1 · Answer 10 · answered Oct 03 '16 at 11:21

control flow is-

static block -> Initialization block -> and finally Constructor.

static block -> This static block will be get executed only once when the control come to the class.(JVM Load this class)

Initialization block -> This Initialization block will be get executed whenever a new object Created for the Class (It will be executed from second statement of the Constructor then following constructor statements- remember First statement of the Constructor will be Super()/this())

Constructor -> This will be get whenever a new object is created.

score 0 · Answer 11 · edited Apr 30 '20 at 19:09

0

Static init block executes at the time of class loading only ones.
Init block executes every time before creating object of the class.

Learn more with this video: Java Tutorial by Rajan Jain : Static Init Block and Init Block in java Video14 - YouTube

edited Apr 30 '20 at 19:09

Ky -

30,724
51
192
308

answered Nov 04 '18 at 19:48

Java Tutorial

1

In what order do static blocks and initialization blocks execute when using inheritance?

11 Answers11

Linked

Related