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.

Solution 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.

Solution 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.

Solution 3

I got a way to do this.

class Derived extends Base
{
    private final int a;

    // make this method private
    private Derived(String someParameter,
                    int tmpVar /*add an addtional parameter*/) {
        // use it as a temprorary variable
        super(hack(someParameter, tmpVar = getValueFromDataBase()));
        // assign it to field a
        a = tmpVar;
    }

    // show user a clean constructor
    Derived(String someParameter)
    {   
        this(someParameter, 0)
    }

    ...
}

Solution 4

As others have said, you can't initialize the instance field before calling the superclass constructor.

But there are workarounds. One is to create a factory class that gets the value and passes it to the Derived class's constructor.

class DerivedFactory {
    Derived makeDerived( String someParameter ) {
        int a = getValueFromDataBase();
        return new Derived( someParameter, a );
    }
}


class Derived extends Base
{
    private final int a;

    Derived(String someParameter, int a0 ) {
        super(hack(someParameter, a0));
        a = a0;
    }
    ...
}

Solution 5

It's prohibited by the Java language specification (section 8.8.7):

The first statement of a constructor body may be an explicit invocation of another constructor of the same class or of the direct superclass.

The constructor body should look like this:

ConstructorBody:

{ ExplicitConstructorInvocationopt BlockStatementsopt }

View more solutions

Comments

[Andy Thomas]

+1 - You're right. Ick. I was thinking of C++. Still -- I don't think the hack is necessary - see my answer.

[Keppil]

This isn't really before the super constructor runs, as OP asked. Probably the closest you can get though.

[Serkan Arıkuşu]

@Keppil I mentioned in the answer "Super constructor will run in any case", this just a hack to initialize a variable in the derived class

[Lazar Petrovic]

This is the best solution in my opinion. The only thing I would change is that I would put a static factory method inside the Derived class.

[Kindred]

@mkilic: Pretty sure