super Keyword in Java

Analogy categoryAnalogies

1. Introduction

The super keyword in Java is a reference used inside a subclass to refer to its immediate superclass. It is used to access parent class fields or methods that have been shadowed or overridden, and to invoke the parent class's constructor.

🏏

Cricket analogy: A state cricket academy's junior coach refers back to the senior national coach's playbook when a drill name clashes with the academy's own version, and always starts a new player's training by first completing the national program's basic induction—like super accessing shadowed members and calling the parent constructor.

Using super is essential whenever a subclass needs to build on top of, rather than completely replace, its parent's behavior or state.

🏏

Cricket analogy: A young all-rounder who wants to add a signature reverse-swing variation still needs the base fast-bowling technique taught by the senior academy first—building on top of, not replacing, the fundamentals, just as super lets a subclass extend rather than discard parent behavior.

2. Syntax

java

class Parent {
    int value = 10;

    Parent() {
        System.out.println("Parent constructor");
    }

    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    int value = 20;

    Child() {
        super();          // calls Parent() constructor, must be first statement
        System.out.println("Child constructor");
    }

    void show() {
        super.show();      // calls Parent's show()
        System.out.println("Child show(), super.value = " + super.value);
    }
}

3. Explanation

super has three main uses. First, super.fieldName accesses a field in the parent class that is shadowed by a field of the same name in the subclass. Second, super.methodName(...) explicitly calls the parent class's version of a method that the subclass has overridden. Third, super(...) invokes a constructor of the parent class.

🏏

Cricket analogy: super.fieldName is like referring to the senior team's official strike rate when the junior team has its own separate stat with the same name; super.methodName() is like a junior bowler explicitly performing the senior academy's classic bowling action instead of their own tweaked version; super(...) is like a rookie completing the national fitness test before starting any team-specific training.

When used to call a constructor, super(...) must be the very first statement in the subclass constructor. If you do not write a call to super(...) explicitly, the compiler automatically inserts a no-argument super() call as the first statement — this only works if the parent class has a no-argument constructor.

🏏

Cricket analogy: A cricketer must pass the board's mandatory fitness certification (super()) before any team-specific training begins, and if they don't explicitly schedule it, the academy automatically enrolls them in the default certification first—just as the compiler inserts a no-arg super() call automatically.

Exam tip: Only one of super(...) or this(...) may appear in a constructor, and it must be the first statement — you cannot use both, and you cannot place either after other statements.

If the parent class does NOT define a no-argument constructor and the subclass does not explicitly call super(args) with matching arguments, the code fails to compile with 'no default constructor available'.

4. Example

java

class Parent {
    int value = 10;

    Parent(String msg) {
        System.out.println("Parent constructor: " + msg);
    }

    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    int value = 20;

    Child() {
        super("initializing");
        System.out.println("Child constructor");
    }

    void show() {
        super.show();
        System.out.println("Child show(), child value=" + value + ", parent value=" + super.value);
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
        c.show();
    }
}

5. Output

text

Parent constructor: initializing
Child constructor
Parent show()
Child show(), child value=20, parent value=10

6. Key Takeaways

super refers to the immediate parent class from within a subclass.
super.field accesses a shadowed field in the parent class.
super.method() calls the parent's version of an overridden method.
super(...) invokes the parent constructor and must be the first statement in the subclass constructor.
If omitted, the compiler inserts an implicit no-argument super() call automatically.