Why does this() and super() have to be the first statement in a constructor?

Question

Java requires that if you call this() or super() in a constructor, it must be the first statement. Why?

For example:

public class MyClass {
 public MyClass(int x) {}
}

public class MySubClass extends MyClass {
 public MySubClass(int a, int b) {
  int c = a + b;
  super(c);  // COMPILE ERROR
 }
}

The Sun compiler says "call to super must be first statement in constructor". The Eclipse compiler says "Constructor call must be the first statement in a constructor".

However, you can get around this by re-arranging the code a little bit:

public class MySubClass extends MyClass {
 public MySubClass(int a, int b) {
  super(a + b);  // OK
 }
}

Here is another example:

public class MyClass {
 public MyClass(List list) {}
}

public class MySubClassA extends MyClass {
 public MySubClassA(Object item) {
  // Create a list that contains the item, and pass the list to super
  List list = new ArrayList();
  list.add(item);
  super(list);  // COMPILE ERROR
 }
}

public class MySubClassB extends MyClass {
 public MySubClassB(Object item) {
  // Create a list that contains the item, and pass the list to super
  super(Arrays.asList(new Object[] { item }));  // OK
 }
}

So, it is not stopping you from executing logic before the call to super. It is just stopping you from executing logic that you can't fit into a single expression.

There are similar rules for calling this(). The compiler says "call to this must be first statement in constructor".

Why does the compiler have these restrictions? Can you give a code example where, if the compiler did not have this restriction, something bad would happen?

Answer 1

The parent class' constructor needs to be called before the subclass' constructor. This will ensure that if you call any methods on the parent class in your constructor, the parent class has already been set up correctly.

What you are trying to do, pass args to the super constructor is perfectly legal, you just need to construct those args inline as you are doing, or pass them in to your constructor and then pass them to super:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                super(myArray);
        }
}

If the compiler did not enforce this you could do this:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                someMethodOnSuper(); //ERROR super not yet constructed
                super(myArray);
        }
}

In cases where a parent class has a default constructor the call to super is inserted for you automatically by the compiler. Since every class in Java inherits from Object, objects constructor must be called somehow and it must be executed first. The automatic insertion of super() by the compiler allows this. Enforcing super to appear first, enforces that constructor bodies are executed in the correct order which would be: Object -> Parent -> Child -> ChildOfChild -> SoOnSoForth

Answer 2

I am fairly sure (those familiar with the Java Specification chime in) that it is to prevent you from (a) being allowed to use a partially-constructed object, and (b), forcing the parent class's constructor to construct on a "fresh" object.

Some examples of a "bad" thing would be:

class Thing
{
    final int x;
    Thing(int x) { this.x = x; }
}

class Bad1 extends Thing
{
    final int z;
    Bad1(int x, int y)
    {
        this.z = this.x + this.y; // WHOOPS! x hasn't been set yet
        super(x);
    }        
}

class Bad2 extends Thing
{
    final int y;
    Bad2(int x, int y)
    {
        this.x = 33;
        this.y = y; 
        super(x); // WHOOPS! x is supposed to be final
    }        
}

Answer 3

class A {
  private final int x;
  public A(int x_) { x = x_; }
  public getX() { return x; }
}

class B extends A {
  private int y = getX();
  public B {
    System.out.println("What is this:" + y);
    super(10);
  }
}

Answer 4

You can use anonymous initializer blocks to initialize fields in the child before calling it's constructor. This example will demonstrate :

public class Test {
    public static void main(String[] args) {
     new Child();
    }
}

class Parent {
    public Parent() {
     System.out.println("In parent");
    }
}

class Child extends Parent {

    {
     System.out.println("In initializer");
    }

    public Child() {
     super();
     System.out.println("In child");
    }
}

This will output :

In parent
In initializer
In child

Answer 5

Because the JLS says so. Could the JLS be changed in a compatible manner to allow it? Yup. However, it would complicate the language spec, which is already more than complicated enough. It wouldn't be a highly useful thing to do and there are ways around it (call another constructor with the result of a method this(fn()) - the method is called before the other constructor, and hence also the super constructor). So the power to weight ratio of doing the change is unfavourable.