CODEWITHSUNDEEP
javainheritanceconstructor
Colin Dumitru
Colin Dumitru

Reputation: 3465

Java inheritance - constructors

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

Upvotes: 11

Views: 14592

Answers (5)

Andrei Sfat
Andrei Sfat

Reputation: 8626

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
       //... 
    }
  }

Upvotes: 4

Andreas Dolk
Andreas Dolk

Reputation: 114837

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.

Upvotes: 4

Bozho
Bozho

Reputation: 597402

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

Upvotes: 17

Stuti
Stuti

Reputation: 1638

It is neccessary to call constructor of super class in case of Java. Therefore, whenever you generate constructor of sub class, super class' constructor is self created by IDE.

It is because whenever base class constructor demands arguments, compiler thinks they are to be filled by base class constructor. In case of default constructor, it is OK. No need to call super() in sub class.

Upvotes: 0

GuruKulki
GuruKulki

Reputation: 26428

This happens when you dont have a default constructor and you are creating an instance with default one. Because If you have any Parameterized constructor then compiler will not insert the default one for you, instead you have to define.

Upvotes: 1

Related Questions