why the getX() method executes first rather than constructor

Question

In the below piece of code why the getX() method executes first rather than constructor:

public class ConsructorQuestion {

    int x = getX();  // same this.getX();
    public int getX() {
        System.out.println(x + "  via method  ");
        return 10;
    }

    public ConsructorQuestion() {
        System.out.println(x+"  via constructor");
    }

    public static void main(String[] args) {
        ConsructorQuestion t = new ConsructorQuestion();
    }

}

Answer 1

Instance variables are initialized before the body of the constructor is executed (but after the body of the super class constructor is executed).

Therefore, in your example, int x = getX(); is executed before the constructor body.

This is equivalent to moving the initialization of x to the first line of the constructor:

int x;
public int getX(){
    System.out.println(x+"  via method  ");
    return 10;
}

public ConsructorQuestion() {
    x = getX();
    System.out.println(x+"  via constructor");
}

Answer 2

Field initializers (and instance initialization blocks) are injected by the compiler into the beginning of every constructor in the class (just after the call to super(...), implicit or explicit) if the constructor doesn't chain to another in the same class (by calling this(...)). So if you look at the bytecode generated, you'll see that your class looks like this:

public class ConsructorQuestion {

    int  x;                                             // ***
    public int getX(){
        System.out.println(x+"  via method  ");
        return 10;
    }

    public ConsructorQuestion() {
        this.x = getX();                                // ***
        System.out.println(x+"  via constructor");
    }

    public static void main(String[] args) {
        ConsructorQuestion t = new ConsructorQuestion();
    }

}

The order in which things are done when constructing instances is covered by JLS§12.5:

Just before a reference to the newly created object is returned as the result, the indicated constructor is processed to initialize the new object using the following procedure:

1. Assign the arguments for the constructor to newly created parameter variables for this constructor invocation.

2. If this constructor begins with an explicit constructor invocation (§8.8.7.1) of another constructor in the same class (using this), then evaluate the arguments and process that constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason; otherwise, continue with step 5.

3. This constructor does not begin with an explicit constructor invocation of another constructor in the same class (using this). If this constructor is for a class other than Object, then this constructor will begin with an explicit or implicit invocation of a superclass constructor (using super). Evaluate the arguments and process that superclass constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, continue with step 4.

4. Execute the instance initializers and instance variable initializers for this class, assigning the values of instance variable initializers to the corresponding instance variables, in the left-to-right order in which they appear textually in the source code for the class. If execution of any of these initializers results in an exception, then no further initializers are processed and this procedure completes abruptly with that same exception. Otherwise, continue with step 5.

5. Execute the rest of the body of this constructor. If that execution completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, this procedure completes normally.

Note the order of #4 and #5.

Answer 3

Javac starts from beginning of the class and initializes the class members first and then proceeds with main.