initialiser block/constructor

[Nabila Mohammad]

Which one is executed first?
Initialiser block or constructor and why?

 class SuperclassA
{
 public SuperclassA()
{
  System.out.println("Constructor in SuperCLassA");
}
}
 
 
class SubclassB extends SuperclassA
{
SubclassB()
{

this(3);
System.out.println("Hi");

System.out.println("Default Constructor in SubclassB");
}

SubclassB(int i)
{
 System.out.println("Non Default Constructor in SubclassB");
 value=i;
 }

{
 System.out.println("Initializer block in SubclassB");
 value=2;
}
 
int value=initialiserExpression();

private int initialiserExpression()
{
 System.out.println("instance initialiser expresssion in SubclassB");
 return 1;
}
 
public static void main (String[] args)
{
 SubclassB objref=new SubclassB();
 System.out.println("Value: "+objref.value);
}
}
 
   

In this code ..the first line of the base constructor is executed whihc leads to the second constructor whihc in turn calls hte base class constructor.
Why does it then execute the innitiliser block instead of the base class constructor.
Also,does the constructor run before initailsing the instance varables or after it?

[marc weber]

Originally posted by Nabila Mohammad:
...Why does it then execute the innitiliser block instead of the base class constructor. Also, does the constructor run before initailsing the instance varables or after it?

Your second question is part of the answer to your first question.

This is all part of the initialization that occurrs before the body of the constructor executes.

Initializer blocks execute and instance variables are initialized in the order they appear in the code, and this all happens before the body of the constructor executes. This allows the constructor to use initialized instance variables.

[marc weber]

Try predicting the output of this code, then compile and run to check it...

class Initialize {
  Initialize() {
    System.out.println("\nConstructor executes after instance initialized.");
  }
 
  int instanceInt1 = valueInstanceInt();
 
  static int staticInt1 = valueStaticInt();
 
  {
    System.out.println("Non-static initializer block executes before constructor...");
  }
 
  public static void main(String[] args) {
    System.out.println("\nFirst line in main. Class is now loaded.");
    System.out.println("Creating object...\n");
    Initialize i = new Initialize();
  }
 
  static {
    System.out.println("Static block executes when class loads...");
  }
 
  static int valueStaticInt() {
    System.out.println("Valuing static int.");
    return 7;
  }
 
  {
    System.out.println("...also in the order it appears.");
  }
 
  static {
    System.out.println("...in the order it appears.");
  }
 
  int valueInstanceInt() {
    System.out.println("Valuing instance int.");
    return 9;
  }
 
  static int staticInt2 = valueStaticInt();
 
  int instanceInt2 = valueInstanceInt();
}

[Nabila Mohammad]

Hey Marc..
Thanks Alot..
That was a great program to understand how line by line execution works.
Thanks..you have been a Biiigg help!
Take Care.

[Nabila Mohammad]

I got Most of it Right..
except the first line which I thought would be executed first.
Thnks.

[Nabila Mohammad]

I still have a small problem...
I excuted another program just to chech the step of execution...
Noticed that..
first all the static variables and blocks get executed according the order in whihc they are written.
Then when the objects are being created the Parent class constructor is first run followed by the initialisng of the non static varibles and block in the order in which they are written
And after that..the base class constructor is run.

i dint get it?
Why is the parent class constructor being run first and not followed by the base class.
or why dint the variables get initialised before any of the constructor is run.
Why only parent class constructor?

[marc weber]

Take a look at the output from this code...

class Test {
  public static void main(String[] args) {
    System.out.println("Creating an instance of Subclass extends Superclass...\n");
    Subclass s = new Subclass();
  }
}
 
class Superclass {
  Superclass() {
    System.out.println(" Superclass - constructor.");
  }
 
  {
    System.out.println(" Superclass - non-static initializer.");
  }
 
  static {
    System.out.println(" Superclass - static initializer.");
  }
}
 
class Subclass extends Superclass {
  Subclass() {
    System.out.println("   Subclass - constructor.");
  }
 
  {
    System.out.println("   Subclass - non-static initializer.");
  }
 
  static {
    System.out.println("   Subclass - static initializer.");
  }
}

[Nabila Mohammad]

ok..
so first Static blocks are executed Superclass and then base class..
Then Superclass non static block and constructor.
and the base class non static block and constructor.
Can you tell me why is it executing this way...
i dint get they Why part of the question..

[ahmed yehia]

Why is the parent class constructor being run first and not followed by the base class.

If you investigate sub- class's Constructor, you will find that it it has an implicit call to super- class's Constructor as the very first statement.

After super- class's Constructor finishes, instance variables/blockes got initialized, finally Constructor's body got executed.

From marc sample:

...
class Subclass extends Superclass {
  Subclass() {
    [B]super(); [/B]// implicit call by the Compiler
    System.out.println("   Subclass - constructor.");
  }
...

[marc weber]

Originally posted by Nabila Mohammad:
...Can you tell me why is it executing this way...
i dint get they Why part of the question...

Consider that a Subclass IS-A Superclass. So the first step in creating a Subclass is to create a Superclass, and then "extend" that Superclass to make it a Subclass.

First, we need the blueprint -- the class itself. The Superclass class initializes first, with static variables and static initializers. When this is done, there is a fully initialized Superclass class to work with, and so the Subclass class can initialize its own static variables and static initializers.

After the class (the blueprint) is fully initialized (from the top down), then we start creating the object.

Again, a Subclass IS-A Superclass, so we start by creating an instance of Superclass, initializing instance variables and executing non-static initializers. When this is done, the Superclass constructor can run (using initialized instance variables, if needed). At that point, there is a fully formed Superclass object to work with. The next step is to initialize the Subclass instance (instance variables and initializers), and finally execute the Subclass constructor.

[Nabila Mohammad]

Thanks Alot..
You explain well.
Good Going! Tc.