Constructor and Class Loading

[Nilesh Srivastava]

Hi Can anyone tell me while loading a class what is the sequence of execution.
Here is a snippet. plz tell me howz this output is coming.

abstract class Actor {
  abstract void act();
}
 
class HappyActor extends Actor {
  HappyActor(){System.out.println("CONST ::: HappyActor");}
  public void act() {
    System.out.println("HappyActor");
  }
}
 
class SadActor extends Actor {
SadActor(){System.out.println("CONST ::: SadActor");}
  public void act() {
    System.out.println("SadActor");
  }
}
 
class Stage {
Stage(){System.out.println("CONST ::: Stage");}
  Actor a = new HappyActor();
  void change() { a = new SadActor(); }
  void go() { a.act(); }
}
 
public class Trans {
  public static void main(String[] args) {
    Stage s = new Stage();
    s.go(); // Prints "HappyActor"
    s.change();
    s.go(); // Prints "SadActor"
  }
}

Please explain me in detail as I have referred so many books that I got confused on this topic.
Why "Happy Actor" is coming before "Stage" ?
[ edited to preserve formatting using the [code] and [/code] UBB tags -ds ]
[ August 30, 2003: Message edited by: Dirk Schreckmann ]

[Anupam Sinha]

Hi Nilesh
Stage's constructor creates an object of type HappyActor. Then you call go() method of the construcor which in turns calls the act() method of the HappyActor and then the actor changes and the same sequence is repeated.

[Nilesh Srivastava]

HI Anupam ,
Thanks for replying but I still stuck on the same very point that why is HappyActor is printed before Stage.
When Stage is instantiated then it will call Stage's constructor and it should print "CONST ::: Stage" on the console.Instead it is executing
Actor a = new HappyActor();
and after executing the HappyActor's constructor it prints "CONST ::: HappyActor" then it is calling Stage's constructor.
According to me the sequence of exection should be
1)Stage's constructor will excute first
2)then HappyActor
3)atlast the sadActor's constructor should run

[Ilja Preuss]

That's the way it is specified in Java (according to http://java.sun.com/docs/books/jls/second_edition/html/execution.doc.html#44670 ):
When you call a constructor, first the super-constructor is called, then *all instance variable initializations are executed* and only then the constructor body is executed.

[Tom Hill]

Can i suggest changing:

class Stage {
  Stage() {
    System.out.println("CONST ::: Stage");
  }
  
  Actor a = new HappyActor();
  
  void change() { 
    a = new SadActor(); 
  }
  
  void go() { 
    a.act(); 
  }
}
 
class Stage {
  Stage() { 
    System.out.println("CONST ::: Stage");
  }
  
  void change() { 
    a = new SadActor(); 
  }
  
  void go() {
    Actor a = new HappyActor();
    a.act();
  }
}
 
OR:
 
class Stage {
  Stage(){
    System.out.println("CONST ::: Stage");
    Actor a = new HappyActor();
  }
  
  void change() { 
    a = new SadActor(); 
  }
  
  void go() { 
    a.act(); 
  }
}

??
[ edited to preserve formatting using the [code] and [/code] UBB tags -ds ]
[ August 30, 2003: Message edited by: Dirk Schreckmann ]

[Anupam Sinha]

Hi Nilesh
I misunderstood the question earlier. I thought that you were asking as why at all Happy actor comes to the stage.
Ok the HappyActor comes before Stage because the constructor of the HappyActor is being executed before that of Stage's.
Look here

[1]   class Stage {
[2]   Stage(){System.out.println("CONST ::: Stage");}
[3]   Actor a = new HappyActor();
[4]   void change() { a = new SadActor(); }
[5]   void go() { a.act(); }
[6]   }

Now before the constructor is executed the variables that have been declared are intialized. Think of it this way, the use of the constructor is to intialize the variables. So before the constructor can be executed line no. 3 is executed. Which declares a variable a of type actor type and intializes it with a reference to an Actor type of Object. To get an Actor reference an Actor type object is created for which the Actor's constructor is executed.
Follow this link to know more about it.

[Tom Hill]

I justtook a few minutes to show the execution order - the two things i said earlier probably arnt appropriate!
2 files: JavaCheck.java and JavaChecker.java

public class OrderCheck {
 
OrderChecker a = new OrderChecker();
 
public OrderCheck(){
System.out.println("OrderCheck Constructor");
}
 
public static void main(String[] args){
System.out.println("Make Instance of OrderCheck");
OrderCheck Chk1 = new OrderCheck();
System.out.println("Make new instance of Orderchecker");
OrderChecker chk = new OrderChecker();
System.out.println("All done");
}
}

public class OrderChecker {
 
public OrderChecker(){
System.out.println("OrderChecker Constructor");
}
 
public void someOrderCheckerMethod(){
           //some method
}
}

[ edited to preserve formatting using the [code] and [/code] UBB tags -ds ]
[ August 30, 2003: Message edited by: Dirk Schreckmann ]

[Nilesh Srivastava]

Hi All,
Thanks you all for the help.
Anupam U specially u cleared my doubts.
Once again thanks a million to u all
Nilesh