Why are constructors not inherited in java?

Question

I am a beginner in java programming language, recently I have studied that constructors can not be inherited in java, Can anyone please explain why?

I have already read this link of C++

Answer 1

In simple words, a constructor cannot be inherited, since in subclasses it has a different name (the name of the subclass).

class A {
   A();
}

class B extends A{
   B();
}

You can do only:

B b = new B();  // and not new A()

Methods, instead, are inherited with "the same name" and can be used.

As for the reason: It would not have much sense to inherit a constructor, since constructor of class A means creating an object of type A, and constructor of class B means creating an object of class B.

You can still use constructors from A inside B's implementation though:

class B extends A{
   B() { super(); }
}

Answer 2

What you are talking about is Java language level. If constructors were inherited, that would make impossible to make class private. As we know method visibility can't be downgraded. Object class has a no argument constructor and every class extends Object, so in case of constructor inheritance every class would have a no argument constructor. That breaks OO principles.

Things are different on bytecode level. When object is created, two operators are called:

1. new - allocates memory for object
2. invokespecial - calls constructor on newly allocated piece of memory

We can modify bytecode so that memory is allocated for Child class and constructor is called from Parent class. In this case we can say that constructors are inherited. One notice if we don't turn off byte code verification, JVM will throw an exception while loading class. We can do this by adding -noverify argument.

Conclusion:

1. Constructors are not inherited on language level due to OO principles
2. Constructors are inherited on bytecode level

Answer 3

Reason mentioned in docs of Inheritance

A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

You can refer docs of Providing Constructors for Your Classes

Answer 4

• A constructor may only be called with new. It cannot be called as a method.
• The constructor name is identical to the class name.

So inheritance is practically not possible as such. However in a construct one might call other constructors.

• In the same class using this(...);
• Of the extended class using super(...);

Example

class A {
    A() { }          // Constructor
    A(int a) { }     // Constructor
    A(boolean c) { } // Constructor
}
class B extends A {
    B() {
        this(3, 7);
    }
    B(int a) {
        super();
    }
    B(String b) {
        super(7);
    }
    B(int a, int c) { // Calls super() implicitly
    }
}
A a = new B(8):

There unfortunately is no possibility to use A's constructor for a boolean:

B b = new B(true): // ERROR

The language designes could have implemented such a thing as:

Generate for every public constructor in the base class, a constructor with the same signature if such a constructor is not defined already. Call super with the same parameters. Call this() if there is a default constructor.

That seems a bit bloating the code. And is not simply a pointer in a virtual method table, by which method inheritance/overriding works.

Answer 5

Constructors are not members of classes and only members are inherited. You cannot inherit a constructor. That is, you cannot create a instance of a subclass using a constructor of one of it's superclasses.

Answer 6

Simple answer I observed, You cannot invoke or use constructors of parent class in child class directly but methods of parent class you can use directly in child class.

In case you have method in child class with same name as in parent class at that time only you need to use "super" keyword to invoke parent class method resolve call ambiguity.

"To invoke" parent class constructor in child class you always need "super" keyword. So parent class constructors are "not directly available" like parent class methods in child class so we can say constructors can not be inherited.

Answer 7

1. If constructors were inherited in child class, then child class would contain a parent class constructor which is against the constraint that constructor should have same name as class name.
2. However, parent class constructor can be called from child class constructor using super().

An example code to demonstrate the concept.

class Base{
   public void Base()
   {
       System.out.println("Inside Base class constructor");
   }
}
class Derived{
   public void Derived()
   {
       super();
       System.out.println("Inside Derived class constructor");
   }
class mainClass{
   public static void main(String args[])
   {
       Derived obj = new Derived();
   }


Output:
Inside Base class constructor
Inside Derived class constructor

Answer 8

No, constructors will not be inherited to subclass, eventhough its a non-static member it will not be inherited to subclass because constructors will not be loaded inside the object, it is used to create the object. Constructors are like a non-static initializer

Answer 9

Only fields, methods, and nested classes are the membe of any class not Constructors. A subclass inherits all the members like (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

Answer 10

Syntactic limitations can often be circumvented should there be any reason for a feature in a conceptual way. With this, I believe, the real reason for not supporting inheritance of constructor is not due to syntactic limitations but rather due to semantics.

Conceptually inheritance provides a mechanism to acquire (or inherit) a behavior and most likely without writing any piece of code since its purpose is to provide code-reuse. For a child class, it makes no case to inherit the behavior of initialization of its parent class. After all, an inherited behavior finds its best use when an external caller can use it without knowing who (in the parent chain) actually has implemented it. As you can see, a caller hardly has any business knowing how a parent class is initialized via its child class, there is no discernible reason for supporting inheritance for a (parent class’s) constructor.

Answer 11

you can't inherited constructors but you can inherit initialized value in constructor like

class test1 {
    int a,b;
    test1(){
        a = 100;
        b = 20;
    }
}

class test2 extends test1 {
    test2(){
        // do something
    }
}

class test {
    public static void main(String[] args) {
        test2 t = new test2();
        int a = t.a;
        int b = t.b;
        System.out.println(a+b);
    }
}

Answer 12

No as stated by Mikhail; constructors are not inherited.

You cannot inherit a constructor from superclass into your subclass. However when an object is instantiated with the "new" operator in java, that object inherit all constructors from it subclass to it superclass(parent) even including those in abstract class(since they are also super class).