Initialize field before super constructor runs?

Question

In Java, is there any way to initialize a field before the super constructor runs?

Even the ugliest hacks I can come up with are rejected by the compiler:

class Base {     Base(String someParameter)     {         System.out.println(this);     } }  class Derived extends Base {     private final int a;      Derived(String someParameter)     {         super(hack(someParameter, a = getValueFromDataBase()));     }      private static String hack(String returnValue, int ignored)     {         return returnValue;     }      public String toString()     {         return "a has value " + a;     } } 

Note: The issue disappeared when I switched from inheritance to delegation, but I would still like to know.

Answer 1

No, there is no way to do this.

According to the language specs, instance variables aren't even initialized until a super() call has been made.

These are the steps performed during the constructor step of class instance creation, taken from the link:

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.

Answer 2

Super constructor will run in any case, but since we are talking about the "ugliest hacks", we can take advantage of this

public class Base {     public Base() {         init();     }      public Base(String s) {     }      public void init() {     //this is the ugly part that will be overriden     } }  class Derived extends Base{      @Override     public void init(){         a = getValueFromDataBase();     } }  

I never suggest using these kind of hacks.