Using the super Keyword
Tags: java, programming, learning, beginners
Published: 2024-06-10 08:39:28

The keyword super refers to the superclass and can be used to invoke the superclass’s methods and constructors. A subclass inherits accessible data fields and methods from its superclass. Does it inherit constructors? Can the superclass’s constructors be invoked from a subclass? This section addresses these questions and their ramifications.

The **this** Reference, introduced the use of the keyword **this** to reference the calling object. The keyword **super** refers to the superclass of the class in which **super** appears. It can be used in two ways:

- To call a superclass constructor.
- To call a superclass method.

## Calling Superclass Constructors

A constructor is used to construct an instance of a class. Unlike properties and methods, the constructors of a superclass are not inherited by a subclass. They can only be invoked from the constructors of the subclasses using the keyword **super**.

The syntax to call a superclass’s constructor is:

`super(), or super(parameters);`

The statement **super()** invokes the no-arg constructor of its superclass, and the statement **super(arguments)** invokes the superclass constructor that matches the **arguments**. The statement **super()** or **super(arguments)** must be the first statement of the subclass’s constructor; this is the only way to explicitly invoke a superclass constructor. For example, the constructor in lines 12–16  **CircleFromSimpleGeometricObject.java**, [here](https://dev.to/paulike/inheritance-superclasses-and-subclasses-5ede), can be replaced by the following code:

`public CircleFromSimpleGeometricObject(
double radius, String color, boolean filled) {
super(color, filled);
this.radius = radius;
}`

You must use the keyword **super** to call the superclass constructor, and the call must be the first statement in the constructor. Invoking a superclass constructor’s name in a subclass causes a syntax error.

## Constructor Chaining

A constructor may invoke an overloaded constructor or its superclass constructor. If neither is invoked explicitly, the compiler automatically puts **super()** as the first statement in the constructor. For example:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m5j8rujturglrlz6zfo5.png)

In any case, constructing an instance of a class invokes the constructors of all the superclasses along the inheritance chain. When constructing an object of a subclass, the subclass constructor first invokes its superclass constructor before performing its own tasks. If the superclass
is derived from another class, the superclass constructor invokes its parent-class constructor before performing its own tasks. This process continues until the last constructor along the inheritance hierarchy is called. This is called _constructor chaining_.

Consider the following code:

```
  public class Faculty extends Employee {
  public static void main(String[] args) {
  new Faculty();
  }
 
  public Faculty() {
  System.out.println("(4) Performs Faculty's tasks");
  }
  }

 class Employee extends Person {
 public Employee() {
 this("(2) Invoke Employee's overloaded constructor");
 System.out.println("(3) Performs Employee's tasks ");
 }

 public Employee(String s) {
 System.out.println(s);
 }
 }
 class Person {
 public Person() {
 System.out.println("(1) Performs Person's tasks");
 }
 }
```

`(1) Performs Person's tasks
(2) Invoke Employee's overloaded constructor
(3) Performs Employee's tasks
(4) Performs Faculty's tasks`

The program produces the preceding output. Why? Let us discuss the reason. In line 3, **new Faculty()** invokes **Faculty**’s no-arg constructor. Since **Faculty** is a subclass of **Employee**, **Employee**’s no-arg constructor is invoked before any statements in **Faculty**’s constructor are executed. **Employee**’s no-arg constructor invokes **Employee**’s second constructor (line 13). Since **Employee** is a subclass of **Person**, **Person**’s no-arg constructor is invoked before any statements in **Employee**’s second constructor are executed. This process is illustrated in the following figure.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w1alfbqqe6m1p41ps5gu.png)

If a class is designed to be extended, it is better to provide a no-arg constructor to avoid programming errors. Consider the following code:

`public class Apple extends Fruit {
 }
 class Fruit {
 public Fruit(String name) {
 System.out.println("Fruit's constructor is invoked");
 }
 }`

Since no constructor is explicitly defined in **Apple**, **Apple**’s default no-arg constructor is defined implicitly. Since **Apple** is a subclass of **Fruit**, **Apple**’s default constructor automatically invokes **Fruit**’s no-arg constructor. However, **Fruit** does not have a no-arg constructor, because **Fruit** has an explicit constructor defined. Therefore, the program cannot be compiled. If possible, you should provide a no-arg constructor for every class to make the class
easy to extend and to avoid errors.

## Calling Superclass Methods

The keyword **super** can also be used to reference a method other than the constructor in the superclass. The syntax is:

`super.method(parameters);`

You could rewrite the **printCircle()** method in the **Circle** class as follows:

`public void printCircle() {
 System.out.println("The circle is created " +
super.getDateCreated() + " and the radius is " + radius);
}`

It is not necessary to put **super** before **getDateCreated()** in this case, however, because **getDateCreated** is a method in the **GeometricObject** class and is inherited by the **Circle** class. Nevertheless, in some cases, as shown in the next section, the keyword **super** is needed.