Object Constructor "Challenge" / problem

[Ronald Vermeij]

Hello Java Greenhorns and Experts,

I have a question about constructors an example with 2 classes:
=====[CLASS EMPLOYEE]=============================
import java.util.*;
public class Employee {
private static final double BASE_SALARY = 15000.00;
private String name;
private double salary;
private Date birthDate;

// Employee constructors
public Employee(String name, double salary, Date DoB) {
this.name = name;
this.salary = salary;
this.birthDate = DoB;
System.out.println("constructor_1 - name,salary,date" );
}
public Employee(String name, double salary) {
this(name, salary, null);
System.out.println("constructor_2 - name,salary" );
}
public Employee(String name, Date DoB) {
this(name, BASE_SALARY, DoB);
System.out.println("constructor_3 - name,date" );
}
public Employee(String name) {
this(name, BASE_SALARY);
System.out.println("constructor_4 - name" );
}
}

=====[CLASS TEST_EMPLOYEE]=============================
import java.util.*;

public class Test_Employee {
private static final double BASE_SALARY = 15000.00;
private String name;
private double salary;
private Date birthDate;

public static void main (String args[]) {
// declare 4 Employee reference variables
Employee E1;
Employee E2;

// create a new Employee object and let E1 point, refer to the new object
E1 = new Employee("ronald");
System.out.println("object 1 created");

// create a new Employee object and let E2 point, refer to the new object
E2 = new Employee("ronald", 100D );
System.out.println("object 2 created");

} // end main
} // end class
=====[END OF CLASS TEST_EMPLOYEE]=============================

Both classes compile well, without any errors

Question
When i run ...>java Test_Employee I get this output as result:

constructor_1 - name,salary,date
constructor_2 - name,salary
constructor_4 - name
object 1 created
constructor_1 - name,salary,date
constructor_2 - name,salary
object 2 created


To my opinion the output should be
constructor_4 - name
object 1 created
constructor_2 - name,salary
object 2 created
since these are the only constructor methods, that match exactly the parameters of the calling test_object

How is this possible?
1. Does the javac compiler simply "glue all type-matching constructors" together and execute them at runtime?

Can you please explain to me how this exactly it works?
Regards, Ronald

[John de Michele]

Ronald:

Please use code tags. People are much more likely to respond to your questions if they don't have to parse unformatted code.

John.

[Sudhakar Sharma]

Hi, This executes well, when you call

E1 = new Employee("ronald"); 

from Employee_Test class it will call the constructor of Employee class

public Employee(String name) {
this(name, BASE_SALARY);
System.out.println("constructor_4 - name" );
} 

inside this constructor you have called the two parameter constructor with the this reference. Therefore the execution control
goes to that

public Employee(String name, double salary) {
this(name, salary, null);
System.out.println("constructor_2 - name,salary" );
} 

Now in this constructor you have called the another one with three parameter, so the execution control goes to that

public Employee(String name, double salary, Date DoB) {
this.name = name;
this.salary = salary;
this.birthDate = DoB;
System.out.println("constructor_1 - name,salary,date" ); 
}

inside this constructor everything is initialized and it prints

constructor_1 - name,salary,date

and return control to the two-parameter constructor from where it was called

and prints

constructor_2 - name,salary

again control returned to the one-parameter constructor and prints

constructor_4 - name

and rest of the output will be produced in the same manner.

may be this will help you to know the control flow and constructor chaining..

[Vaibhav Mittal]

Imagine it like a stack.Let me tell you the flow of control,may be that will help you understand:
For E1:
1. First calls the one argument constructor which takes string as argument since that is the matching constructor.
2. The constructor

 
public Employee(String name, double salary) { 
          this(name, salary, null); 
          System.out.println("constructor_2 - name,salary" ); 
} 

is called next. This in turns calls

 
public Employee(String name, double salary, Date DoB) { 
this.name = name; 
this.salary = salary; 
this.birthDate = DoB; 
System.out.println("constructor_1 - name,salary,date" ); 
} 
   

3. This is where the values are assigned. Now constructor_1 is printed out along with the values received for the arguments.
4. Since this constructor was called by

 
public Employee(String name, double salary) { 
          this(name, salary, null); 
          System.out.println("constructor_2 - name,salary" ); 
} 

constructor_2 gets printed out next.
similarly this constructor was called by

 
public Employee(String name) { 
this(name, BASE_SALARY); 
System.out.println("constructor_4 - name" ); 
} 
} 

constructor_4 is printed out.

I am sure you can figure it out for E2.
it is easier to think of it as a stack. if the constructor are named constructor_1,2,3,4 then the stack is arranged as follow:
constructor_1
constructor_2
constructor_4
Hope this answers your doubts. if you have any doubts or clarifications please ask.

[Ronald Vermeij]

Sudhakar Sharma, Vaibhav Mittal wrote:Hi, This executes well, when you call
inside this constructor you have called the two parameter constructor with the this reference.

THAT is what the error in my mind-frame, That was what i did not noticing Sudhakar && Vaibhav.
I was under the wrong assumption that the Employee class had 4 separate and different single constructors.

Thanks for pointing my "newbie java nose" to the fact that multiple "constructor" of the SAME Object called each other!

I hope i do understand it now the right way (see below)

call to constructor 1 -> execute_1 -> return to TestEmployee Class
call to constructor 2 -> execute_2 -> call to constructor 1 -> execute_1 -> return to TestEmployee Class
call to constructor 3 -> execute_3 -> call to constructor 1 -> execute_1 -> return to TestEmployee Class
call to constructor 4 -> execute_4 -> call to constructor 1 -> execute_1 -> return to TestEmployee Class

Thanks both for your crystal clear explanation!