Java super Keyword
Usage and Examples

super Keyword in Java

In Java, the super keyword is used to refer to the immediate parent class of a subclass. It acts as a bridge to access the superclass’s variables, methods, or constructors from a subclass.

This is especially useful when the subclass overrides a method or variable, and you still want to access the original version from the parent class.

Why is super Important?

Java follows the principles of object-oriented programming. One of those principles is inheritance, where a subclass inherits features from a superclass. Sometimes, the subclass wants to:

• Call a method defined in the superclass
• Access a variable hidden by its own declaration
• Call a specific constructor of the superclass

That’s where super becomes powerful and essential.

1. Using super to Call Superclass Method

If a method in the child class overrides a method from the parent, you can still call the parent version using super.methodName().

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }

    void makeSound() {
        super.sound();  // Call parent class method
        sound();        // Call current class method
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
    }
}

Animal makes a sound
Dog barks

2. Using super to Access Superclass Variables

If both superclass and subclass have variables with the same name, super helps in accessing the superclass’s variable.

class Vehicle {
    int speed = 60;
}

class Car extends Vehicle {
    int speed = 100;

    void displaySpeed() {
        System.out.println("Speed of Car: " + speed);
        System.out.println("Speed of Vehicle: " + super.speed);
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.displaySpeed();
    }
}

Speed of Car: 100
Speed of Vehicle: 60

3. Using super() to Call Superclass Constructor

When creating a subclass object, the constructor of the superclass is automatically called. But if the superclass has a parameterized constructor, you need to explicitly call it using super(arguments).

class Person {
    Person(String name) {
        System.out.println("Person: " + name);
    }
}

class Student extends Person {
    Student(String name) {
        super(name);  // Call the constructor of Person
        System.out.println("Student: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Alice");
    }
}

Person: Alice
Student: Alice

Things to Remember

• super must be the first statement in the subclass constructor when calling the superclass constructor.
• You can’t use super in a static context since it refers to an instance.
• super helps resolve naming conflicts between parent and child class members.

Real-Life Analogy

Imagine you’re using a customized smartphone interface provided by a brand (the subclass), but sometimes you want to access the default Android settings (the superclass). The super keyword acts like a backdoor to reach those default settings, even when they’ve been overridden or hidden.

When Should You Use super?

• When subclass methods/fields override superclass methods/fields but you still want to refer to the original version.
• When passing parameters to a constructor in the superclass.