How is a constructor executed?

I am making some revisions from the lecture slides and it says a constructor is executed in the following way:

1. If the constructor starts with this, recursively execute the indicated constructor, then go to step 4.

2. Invoke the explicitly or implicitly indicated superclass constructor (unless this class is java.lang.Object).

3. Initialise the fields of the object in the order in which they were declared in this class.

4. Execute the rest of the body of this construc开发者_如何学Ctor.

What I don't understand is that a constructor can never "start" with this, because even if it forms no class hierarchy/relationship then super() is inserted by default.

How would this fit in with the description above?

A constructor (for every class except java.lang.Object) has to start with either "super()", to call its superclass' constructor, or "this()", to call another constructor of the same class. If you don't include either of those in your constructor the compiler will insert a call to super(). It's fine for a constructor to start with a call to another constructor in the same class, as long as eventually a constructor in the class gets called that calls a superclass constructor.

I don't think you're right, or I don't understand the problem. From the Java Language Spec:

If a constructor body does not begin with an explicit constructor invocation and the constructor being declared is not part of the primordial class Object, then the constructor body is implicitly assumed by the compiler to begin with a superclass constructor invocation "super();", an invocation of the constructor of its direct superclass that takes no arguments.

As such a constructor can start with this(...) which calls another constructor of the same class. Only when a constructor is called which does not start with either this(...) or super(...), super() is called automatically.

What I would say is that after an object is constructed super(...) has been called (if the class is not java.lang.Object).

here a more or less practical example for using this(...)

public class Car {

    private final int numberOfDoors;

    public Car(int doors) {
        numberOfDoors = doors;
    }

    public Car() {
        this(4);    // default is 4 doors, calls the constructor above
    }
}

the first statement in constructor body should be this or super , if nothing is there compiler by defalt keeps a super() keyword (with no argument). so the Constructor body executes in this way:

1. Execution will happen on the basis of this or super keyword, then

2. it will execute all IIB's (as top down approach), then

3. it will execute all the statments kept by the programmer (like sop, initilization)

Class A{
    A() {
        this(10);    //or super,....... execution statement 1
        // executing IIB's, execution statement 2
        System.out.println("from A()");   // execution statement 3
    }

    A(int i) {
        System.out.println("from A(int)");
    }        
    {
        System.out.println("from IIB-1");
    }

    public static void main(String[] args){
        A a = new A(); //calling constructor A()
        System.out.println("from main");
    }
    {
        System.out.println("from IIB-2");
    }
}

Output:

from IIB-1
from IIB-2
from A(int)
from A()
from main

In Java, when you instantiate any object with new like C c = new C(); it delegate its super class constructor to create it first.

So in your case new C() --> Delegates to --> B() --> Delegates to A()
So execution flow is as below:

1) A() will Prints : 2
2) B() will calls  B(1 )  prints  3 and control return to B() constructor
3) B() will prints : 4
4) C() will prints : 6

I hope it is now clear