Java: How constructors and methods behave with inheritance

Question

Java seems to be inconsistent in how class constructors and methods deal with inheritance.

Case 1 - Methods:

public class HelloWorld
{
  public static void main(String[] args)
  {
    Bee b = new Bee();
    b.foo();
  }
}

class Insect {
  public void foo() {
    this.bar();
    System.out.println("Insect foo");
  }

  public void bar() {
    System.out.println("Insect bar");
  }
}

class Bee extends Insect {
  @Override
  public void foo() {
    super.foo();
    System.out.println("Bee foo");
  }

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

The above code outputs the following:

Bee bar

Insect foo

Bee foo

Notice the call to "this.bar()" in Insect's foo() method actually goes back and calls Bee's bar() method (instead of calling Insect's bar() method).

Case 2 - Constructors:

public class HelloWorld
{
  public static void main(String[] args)
  {
    Bee i = new Bee(1);
  }
}

class Insect {
  public Insect(int size) {
    this(size, 123);
    System.out.println("Constructor: Insect size");
  }

  public Insect(int size, int height) {
    System.out.println("Constructor: Insect size, height");
  }
}

class Bee extends Insect {
  public Bee(int size) {
    super(size);
    System.out.println("Constructor: Bee size");
  }

  public Bee(int size, int height) {
    super(size, height);
    System.out.println("Constructor: Bee size, height");
  }
}

The above outputs the following.

Constructor: Insect size, height

Constructor: Insect size

Constructor: Bee size

Notice the call to "this(size, 123);" in Insect's constructor goes to Insect's 2nd constructor instead of bee's 2nd constructor.

So in summary, method calls go back to the subclass while constructor calls stay in the superclass. Can anyone explain why?

[JLS 8.8](https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.8): "Constructor declarations are not members. They are never inherited and therefore are not subject to hiding or overriding" — KevinO, May 23 '17 at 01:49
shouldn't case 2 be a compilation error? because of the @Override on the constructor of the Bee class — Samip Suwal, May 23 '17 at 02:04
KevinO basically got it. Constructors do not participate in inheritance. It may be a bit surprising but that is the way the language is specified. — markspace, May 23 '17 at 02:05
Overriding a constructor cannot be done, I can see you have used @Override on constructor. — Aritra Chatterjee, May 23 '17 at 02:08
This is basic textbook stuff that you just have to learn and accept as gospel. Your life as a Java programmer will be much easier once you do. — Kevin Anderson, May 23 '17 at 02:13
Woops, added those @Overrides right before I posted. Anyway the answers make sense to me, thanks guys. — Nightfire, May 23 '17 at 02:17
You may find reading this fruitful, if you are wondering the reasons why: https://stackoverflow.com/questions/1644317/java-constructor-inheritance — Ryan Leach, May 23 '17 at 02:18
Questions like this can be answered independently if one looks up the answers in the Java documentation. — Lew Bloch, May 23 '17 at 02:44

GhostCat · Answer 1 · 2017-08-28T13:06:57.680

Beyond the correct information in the comments about methods being not the same as constructors - you are actually over-simplifying things.

You see, when you write constructors, you have to decide if you intend to use a "same class" constructor (when you use this()) - or if you want to invoke a super class constructor (using super()) instead. There is no middle ground here - you have to be explicit about this!

Keep in mind: the responsibility of a constructor is to initialize an object of the corresponding class. It can make a huge difference if you call this(whatever) or super(whatever) within your constructors.

The compiler can't know what you intend to do. Therefore you have to be explicit about the exact other constructor you want to be invoked.

And beyond that - it simply doesn't make sense to have polymorphism kick in here like this. You absolutely want that object initialization takes place as you expect it to happen. Because wrongly initialized objects for sure create problems later on.

Your idea of making constructors polymorphic basically means that you determine at runtime which constructor to invoke. But you already know that you are in class X, and that you have to initialize a new X object. There is nothing to gain from allowing polymorphism here. To the contrary - doing so would allow for very strange and bizarre problems that would be purely runtime only!

Java: How constructors and methods behave with inheritance

1 Answers1