Java Constructor Inheritance

Suppose constructors were inherited... then because every class eventually derives from Object, every class would end up with a parameterless constructor. That's a bad idea. What exactly would you expect:

FileInputStream stream = new FileInputStream();

to do?

Now potentially there should be a way of easily creating the "pass-through" constructors which are fairly common, but I don't think it should be the default. The parameters needed to construct a subclass are often different from those required by the superclass.

When you inherit from Super this is what in reality happens:

public class Son extends Super{  // If you dont declare a constructor of any type, adefault one will appear.  public Son(){    // If you dont call any other constructor in the first line a call to super() will be placed instead.    super();  }}

So, that is the reason, because you have to call your unique constructor, since"Super" doesn't have a default one.

Now, trying to guess why Java doesn't support constructor inheritance, probably because a constructor only makes sense if it's talking about concrete instances, and you shouldn't be able to create an instance of something when you don't know how it's defined (by polymorphism).

Because constructing your subclass object may be done in a different way from how your superclass is constructed. You may not want clients of the subclass to be able to call certain constructors available in the superclass.

A silly example:

class Super {    protected final Number value;    public Super(Number value){        this.value = value;    }}class Sub {    public Sub(){ super(Integer.valueOf(0)); }    void doSomeStuff(){        // We know this.value is an Integer, so it's safe to cast.        doSomethingWithAnInteger((Integer)this.value);    }}// Client code:Sub s = new Sub(Long.valueOf(666L)): // Devilish invocation of Super constructor!s.doSomeStuff(); // throws ClassCastException

Or even simpler:

class Super {    private final String msg;    Super(String msg){        if (msg == null) throw new NullPointerException();        this.msg = msg;    }}class Sub {    private final String detail;    Sub(String msg, String detail){        super(msg);        if (detail == null) throw new NullPointerException();        this.detail = detail;    }    void print(){        // detail is never null, so this method won't fail        System.out.println(detail.concat(": ").concat(msg));    }}// Client code:Sub s = new Sub("message"); // Calling Super constructor - detail is never initialized!s.print(); // throws NullPointerException

From this example, you see that you'd need some way of declaring that "I want to inherit these constructors" or "I want to inherit all constructors except for these", and then you'd also have to specify a default constructor inheritance preference just in case someone adds a new constructor in the superclass... or you could just require that you repeat the constructors from the superclass if you want to "inherit" them, which arguably is the more obvious way of doing it.