I am confused with the follwing code.

code:

---

class Base{
 Base(int i){
  test();
 }
 void test() {
  System.out.println("Base.test()");
 }
 Base(){
  this(5);
  System.out.println("base constructor called");
 }
}
public class Child extends Base {
 Child(int i){
   test ();
 }
 Child(float f){
  this ((int)f);
 }
 void test() {
 System.out.println("Child.test()");
 }
 static public void main(String[] a) {
 Child y =new Child(10.8f);
 }
}

---

Why not?
Base.test()
Base construtor called
Child.test().

Thanks.

Step1 :
You make new Child(float f) . This form of Child class's constructor diverts to Child(int i) form of constructor by calling this((int)f);

Step2 So the foll constructor is called.

      Child(int i){
	   test ();
      }

      Child(int i){
           super();
            test ();
      }

Step 3
Since super() is implicitly provided by the compiler as the FIRST statement in Child(int i){.. } constructor,the super class Base() { } constructor called. This diverts to Base(int i) {..} constructor.

Step 4
In Base(int i) { } version calls test() method, since we are started creating new Child(..) from the main method, the overridden version of the test() method in Child class is executed which prints the first line of output Child.test()

Step 5
Then after finishing the Base(int i) { } version constructor, control comes back to Base() {..} which prints the 2nd line of output base constructor called

step 6
Now control comes back to Child(int i) { } version, and executes the next statement test() (same execution flow as was in Base() constructor) is executed , which calls the overridden version of the test() in Child class and prints the 3rd line of output Child.test()

What is the compiler rule to provide super() in the subclass constructor ?
Is that the following:
Compiler provides super() in the first line for all the contructor except for those don't implicit call for its own constructor like this().
Does compiler provide this(), just like super() in the above statement ?

class Base {
    Base(){
    }
    Base(int i){
    }
    void printMe() {
	System.out.println("BasePrint");
    }
}
class Child extends Base {
   Child(int i){//Ok ONLY super() inserted automatically
   }				
   Child(double d){
     super(); //Same as above. Since you inserted a super class constructor as 1st statement the compiler 
//doesn't insert super() as in the above case
    }
   Child(float f){
      this ((int)f);//Ok No super() inserted
   }
   Child(short s) {
      super(10);//Ok No this() inserted
   }
   /*Child(byte b) {
      this(10);
      super(10);//Not OK either one of this(..) or super(..) can be present but NOT both
	}
    */
   /*Child(char c) {
       System.out.println("maha");
       super(10);//Not OK. super(..) or this(..) MUST be first statement in a constructor
     }*/
    /*void m1() {
       super();//Not Ok super(..) this(..) can be present only in constructors
    // NOT in methods.
    }*/
   void printMe() {
      System.out.println("SubPrint");
      super.printMe();	//OK because super.someMethod() is different from super(..) constructor invocation
    }
    static public void main(String[] a) {
    }
}