The super keyword in Java is a powerful tool for interacting with a class’s parent or superclass. It allows you to access members (methods and fields) of the superclass, even if they are hidden or overridden in the subclass. Understanding how to use super is crucial for effective inheritance and code reuse in Java.

Key Uses of the ‘super’ Keyword

The super keyword serves several critically important purposes in Java:

• Calling the Superclass Constructor: super() is used to invoke the constructor of the superclass. This is frequently enough necessary to initialize the superclass’s state before the subclass’s constructor executes [[1]].
• accessing Overridden Methods: When a subclass overrides a method from its superclass, super.methodName() allows you to call the superclass’s implementation of that method.
• Accessing Hidden Fields: If a subclass declares a field with the same name as a field in its superclass, super.fieldName allows you to access the superclass’s field.

The super keyword can be used to call overridden methods, access hidden fields or invoke a superclass’s constructor. [[1]]

‘super()’ for Constructor Invocation

The most common use of super is to call the superclass’s constructor. If a subclass constructor doesn’t explicitly call super(), the Java compiler automatically inserts a call to the superclass’s no-argument constructor. Though, if the superclass only defines parameterized constructors, the subclass must explicitly call one of them using super(arguments).

For example:

class Animal {
    Animal(String name) {
        System.out.println("Animal constructor called with name: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // Calling the Animal constructor
        System.out.println("Dog constructor called with name: " + name);
    }
}
            

in this example, the Dog constructor uses super(name) to call the Animal constructor, ensuring that the Animal class is properly initialized before the Dog class.