Java inheritance - constructors

Question

While studying for my finals, I came across the following statement in the book from which I am currently studying. Considering the following code :

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

class B extends A {
    public B(int x ) {   }
}

is it mandatory to call the constructor of class A in the constructor of class B(super(x)). The book states that it's not mandatory, because they have the exact number and type of parameters. But when I try this in a java compiler, the following error gets thrown :

constructor A in class A cannot be applied to given types; required: int found: no arguments reason: actual and formal argument lists differ in length

Answer 1

The compiler automatically inserts super() in the beginning.

However, even constructors arguments, super() (without arguments) is added which invokes the default constructor of the superclass. And you don't have one, hence the error.

You have to specify super(x) (to invoke A(x)), or define a no-argument constructor.

By the way, Eclipse compiler gives a way better error message:

Implicit super constructor A() is undefined. Must explicitly invoke another constructor

Answer 2

It looks like the compiler tries to create a call to the superclasses default constructor with super(), which isn't avaliable:

required: int
found:    no arguments

But back to your book: I've never heard of a rule that you can skip the super statement in a constructor if the actual constructor has the exact same parameter list as a constructor in the direct superclass. Only a call to the superclass's default constructor is added implicitly (super()) but that requires that the superclass has a default constructor.

In contrast to what's written in your book (or in contrast to your understanding of the written text), here's a sentence from the language spec:

If a constructor body does not begin with an explicit constructor invocation and the constructor being declared is not part of the primordial class Object, then the constructor body is implicitly assumed by the compiler to begin with a super class constructor invocation “super();”, an invocation of the constructor of its direct superclass that takes no arguments.

Answer 3

If you have a the base class having a default constructor (no-arg constructor), when you extend B, you don't need to explicitly call super() because it is called any way.

But when you have a constructor with arguments, when making the contructor with parameters in B, you need to pass in super() a parameter for A

example :

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

  class B extends A {
    public B(int x ) 
    {
       super(x); // need to specify the parameter for class A
       //... 
    }
  }