Execution Order of Static, Init, Instance Blocks

[Sandra Bachan]

Somehow, I am having difficulty with this concept.

At the end of Chapter 3 of Sierra/Bates, they give code:

class Bird { 
   { System.out.print("b1 "); } 
   public Bird() { System.out.print("b2 "); }
}
class Raptor extends Bird {
   static { System.out.print("r1 "); } 
   public Raptor() { System.out.print("r2 "); } 
   { System.out.print("r3 "); } 
   static { System.out.print("r4 "); }
}
class Hawk extends Raptor {
   public static void main(String[] args) { 
      System.out.print("pre "); 
      new Hawk(); 
      System.out.println("hawk ");
   }
}

When I traced it, I got the output:

pre r1 r4 b1 b2 r3 r2 hawk

However, the book says output is:

r1 r4 pre b1 b2 r3 r2 hawk


Why on earth would the static init blocks of Raptor execute before Hawk outputs "pre." Is an instance of Hawk created as soon as the main() function begins running? And if that is the case, why doesn't the static init blocks of Bird execute, then Raptor because Bird is the Superclass of Raptor.

I am really missing the concept here, please clarify

[Borja Campina]

class Hawk extends Raptor { // <- Raptor class is loaded then all static init blocks are executed.
   public static void main(String[] args) { 
      System.out.print("pre "); 
      new Hawk(); // <- Object created, instance block are executed, constructor after.
      System.out.println("hawk ");
   }
}

To try to help a little more, I show you an example:
Case class B extends A, execution order:
- class a static init block
- class b static init block
- class a instance init block
- class a constructor
- class b instance init block
- class b constructor

Sorry for my english.

[Sridhar Gudipalli]

Lets see the below code. Sysout statements are scattered in the program. Please dont confuse. Just observe the output and find out the rules yourself.

Source: SCJP K&B - Chapter#3, Q#14 (Modified the program to better understand)

class Bird { 
	{ System.out.println("Bird instance init "); } 
	static { System.out.println("Bird static init 1"); }
	public Bird() { System.out.println("Bird Constructor"); }
	static { System.out.println("Bird static init 2"); }
}

class Raptor extends Bird {
	static { System.out.println("Raptor static init 1"); }
	{ System.out.println("Raptor instance init "); } 
	public Raptor() { System.out.println("Raptor Constructor"); }
	static { System.out.println("Raptor static init 2"); }
}
public class Hawk extends Raptor {

	static { System.out.println("Hawk static init 1"); }
	
	{ System.out.println("Hawk instance init "); } 
	public Hawk() { System.out.println("Hawk Constructor"); }
	
	static { System.out.println("Hawk static init 2"); }

	public static void main(String[] args) { 
		System.out.println(">>>> In main method Before instance "); 
		new Hawk(); 
		System.out.println(">>>> In main method After instance ");
	}

	static { System.out.println("Hawk static init 3"); }
}

[Sridhar Gudipalli]

Sandra Bachan wrote:
Why on earth would the static init blocks of Raptor execute before Hawk outputs "pre." Is an instance of Hawk created as soon as the main() function begins running? And if that is the case, why doesn't the static init blocks of Bird execute, then Raptor because Bird is the Superclass of Raptor.

Please see the explanation in answer (K&B).
1) Static init blocks are executed at class loading tme.
2) Instane init blocks run right after the super() in a constructor.

Sandra Bachan wrote:why doesn't the static init blocks of Bird execute, then Raptor because Bird is the Superclass of Raptor.

Please observe carefully, if the Bird has "static" init block.

[Sandra Bachan]

I appreciate the time and effort to explain this to me. I think this is one of my weaker areas, as I had a similar question about a week ago. Will have to study this objective a bit harder.

Cheers!

[Sahil Kapoor]

What happens When class is loaded by JVM

When JVM loads a class into the memory , it executes its static blocks.

What Happens when object is instantiated

When any class's object is created , JVM executes its init blocks followed by constructors.

What happens when an JVM is given a command with new <Some class>

When JVM encounters new <Some class>, it creates an object of its parent class,( Ofcourse, recursively applying this definition means , if this class has a parent, then its parent is created first) and then comes down to create an object of the class to whom we applied new.

Integrate the above three facts , you would get an Answer to your question.

Thanks ~!!!

[Ulrich Vormbrock]

Here another rule of thumb concerning constructors and "instance init block" - I want to emphasize this because taking several mock exams, I was unable to answer to such questions spontaneously: what comes first - the instance init block or the constructor? How is this related to the call to super() or this()?

There has been one crucial hint which helped me to get a deeper understanding: an instance init block can reduce redundancy ... provided that several constructors (the overloaded ones in the same class) have to share a member.

Consequently, it's obvious that a constructor has to do his work AFTER the instance init block has finished.

Below, please find an example in which a variable called constructorCalls is accessed by multiple constructors. If the instance init block was called only after completion of a constructor, such approach of sharing variables would not make sense.

public class MultipleConstructors extends FatherOfMultipleConstructors {

    static String constructorCalls = null;

    MultipleConstructors() {
	    this(1);
	    System.out.println("MultipleConstructors() can now access variables from instance init block");
	    constructorCalls += "MultipleConstructors() ";
	    // this(1); // don't try this - this (and super) always at first position
    }

    MultipleConstructors(int i) {
	    this(1, 1);
	    System.out.println("MultipleConstructors(int i) can now access variables from instance init block");
	    constructorCalls += "MultipleConstructors(int i) ";
    }

    MultipleConstructors(int i, int j) {
	    //super(); // commented out or not ... it doesn't matter
	    System.out.println("MultipleConstructors(int i, int j) can now access variables from instance init block");
	    constructorCalls += "MultipleConstructors(int i, int j) ";
    }

    // instance init block
    {
	    constructorCalls = "constructorCalls has been accessed by ... ";
	    System.out.println("instance init block");
    }

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

    public static void main(String[] args) {

	    new MultipleConstructors(); // call the non-arg constructor
	    System.out.println(constructorCalls);
    }
}

class FatherOfMultipleConstructors {
    
    FatherOfMultipleConstructors() {
	    System.out.println("FatherOfMultipleConstructors() has been invoked");
    }
}

And here's the ouput:

static init block
FatherOfMultipleConstructors() has been invoked
instance init block
MultipleConstructors(int i, int j) can now access variables from instance init block
MultipleConstructors(int i) can now access variables from instance init block
MultipleConstructors() can now access variables from instance init block
constructorCalls has been accessed by ... MultipleConstructors(int i, int j) MultipleConstructors(int i) MultipleConstructors()

As you can see in the ouput, the instance init block is called after all constructor's calls to super() (or this()) and before the constructors have finished their work.
Hope this explanation is not too confusing...