Why are member objects initialized after the super class's constructor?

Question

I ran into an interesting problem yesterday and while the fix was quite simple, I'm still a bit fuzzy on the "why" of it.

I have a class that has a private member variable that is assigned when it is instantiated, however if it is used in an abstract function that is called by the super class's constructor, the variable does not have a value. The solution to the problem was quite simple, I simply had to declare the variable as static and it was assigned correctly. Some code to illustrate the problem:

class Foo extends BaseClass
{
    private final String bar = "fooBar!";
    public Foo()
    {
        super();
    }

    @Override 
    public void initialize()
    {
        System.out.println(bar);
    }
}

And the base class:

abstract class BaseClass
{
    public BaseClass()
    {
        initialize();
    }

    public abstract void initialize();
}

In this example, when we call new Foo(); it will output (null) instead of the expected fooBar!

Since we're instantiated an object of type Foo, should its members not be allocated and assigned prior to calling its (and consequently its super class's) constructor? Is this specified somewhere in the Java language or is it JVM specific?

Thanks for any insight!

Answer 1

The assignment of bar = "fooBar!"; is inlined into the constructor during compile time.

The superclass constructor runs before the subclass constructor, hence it would only be natural that the statement is executed afterwards.

Generally though, it's bad practice to call overridable methods from a constructor.

Answer 2

It is as defined by the Java Language Specification. Changing it to static will almost never be and acceptable solution in real world situation.

See JLS 4.12.5 Initial Values of Variablesand JLS 8.3.2 Initialization of Fields

Overall, it is bad practice to call a non-final method from a constructor. the reason being that it could (and if the method is abstract then definitely does) call method in the class that has not yet been initialized: When new Foo() is executed, the BaseClass initializer (constructor) gets called before the Foo constructor, so Foo.initialize is essentially working on an Object that has not been fully constructed yet.