A derived Java class can call a constructor in its base class using the super keyword. In fact, a constructor in the derived class must call the super's constructor unless default constructors are in place for both classes.

In this article, we are going to explore constructors in an object. We can create inheritance in terms of object, i.e. a parent object can have one or multiple child objects. Now we can call the constructors of a parent object from the child object.

Constructor

These are the instances of a class that is commonly referred to as an Object. The new keyword from JavaScript uses a constructor to be called when an object needs to be declared or created. We can set properties into an object using these constructors.

Inheritance in JavaScript

This is the ability of an object to access the properties or methods of another object. This ability is known as Inheritance. Objects can inherit properties and methods from the parent Objects. And the child objects can extend the parent properties.

For calling the constructor of a parent class we can use the super keyword. The super() method from the constructor method is used for the invocation of the constructor method of the parent class to get access to the parent’s properties and methods.

Example 1

In the below example, we have created 2 classes i.e. parent and the child class. The child class extends the parent class. Now for calling the constructor from the parent class we will use the super() method that will be responsible for calling this constructor and executing the actions necessary.

# index.html

   Property Descriptors


   

      Welcome To Tutorials Point
   
   

Output

On successful execution of the above program you will find the result in the console similar as below screenshot

Example 2

In the below example, we are calling the instance of the base class from the child class. Since the instance created is of base class the method for child class will not be called.

If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a hidden field (although hiding fields is discouraged). Consider this class, Superclass:

public class Superclass {

    public void printMethod() {
        System.out.println("Printed in Superclass.");
    }
}

Here is a subclass, called Subclass, that overrides printMethod():

public class Subclass extends Superclass {

    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

Within Subclass, the simple name printMethod() refers to the one declared in Subclass, which overrides the one in Superclass. So, to refer to printMethod() inherited from Superclass, Subclass must use a qualified name, using super as shown. Compiling and executing Subclass prints the following:

Printed in Superclass.
Printed in Subclass

Subclass Constructors

The following example illustrates how to use the super keyword to invoke a superclass's constructor. Recall from the

public class Subclass extends Superclass {

    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

9 example that

Printed in Superclass.
Printed in Subclass

0 is a subclass of

public class Subclass extends Superclass {

    // overrides printMethod in Superclass
    public void printMethod() {
        super.printMethod();
        System.out.println("Printed in Subclass");
    }
    public static void main(String[] args) {
        Subclass s = new Subclass();
        s.printMethod();    
    }
}

9. Here is the

Printed in Superclass.
Printed in Subclass

0 (subclass) constructor that calls the superclass constructor and then adds initialization code of its own:

public MountainBike(int startHeight, 
                    int startCadence,
                    int startSpeed,
                    int startGear) {
    super(startCadence, startSpeed, startGear);
    seatHeight = startHeight;
}   

Invocation of a superclass constructor must be the first line in the subclass constructor.

The syntax for calling a superclass constructor is

or:

With

Printed in Superclass.
Printed in Subclass

3, the superclass no-argument constructor is called. With

Printed in Superclass.
Printed in Subclass

4, the superclass constructor with a matching parameter list is called.

---

Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error.

Printed in Superclass.
Printed in Subclass

5 does have such a constructor, so if

Printed in Superclass.
Printed in Subclass

5 is the only superclass, there is no problem.

---

If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of

Printed in Superclass.
Printed in Subclass

5. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.

Can we call constructor of parent in class?

Which keyword is used to call a constructor?

Which keyword can be used to access parent class members?