super Keyword Usage and Examples

Learn how to use the Java super keyword to access superclass methods, constructors, and variables. Includes beginner-friendly explanations and real-world examples.

This reference explains super Keyword Usage and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

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.

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.

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

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

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

• 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.

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 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.

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.