The super Keyword in Java

The super keyword in Java lets a child class reach its parent class: to call the parent's constructor, to reuse a method it has overridden, or to read a hidden field. If this means "me", super means "the parent part of me".

What is super in Java?

When you create an object of a child class, it contains a "parent layer" built from the parent class. Think of a house extension: the new rooms are yours, but the original house is still there underneath. super lets the child's code reach that original layer. It only makes sense with inheritance.

Manager(String name, int teamSize) {
    super(name);          // let Employee set the name
    this.teamSize = teamSize;
}

@Override
String describe() {
    return super.describe() + ", manages " + teamSize;
}

class Parent { String label = "parent"; }
class Child extends Parent {
    String label = "child";
    String both() { return label + "/" + super.label; }
}

public String start() {
    return Printer.super.start();
}

A complete example: Employee and Manager

class Employee {
    protected final String name;

    Employee(String name) {
        this.name = name;
    }

    String describe() {
        return name + " is an employee";
    }
}

class Manager extends Employee {
    private final int teamSize;

    Manager(String name, int teamSize) {
        super(name);                       // 1. parent sets up 'name'
        this.teamSize = teamSize;          // 2. child sets up its own field
    }

    @Override
    String describe() {
        return super.describe()            // 3. reuse the parent's text...
             + " who manages " + teamSize; //    ...and add to it
    }
}

System.out.println(new Manager("Asha", 6).describe());

Asha is an employee who manages 6

• super(name) — runs Employee's constructor so the inherited name field is set properly.
• super.describe() — calls Employee's version. Writing just describe() here would call Manager's own method again and loop forever (a StackOverflowError).

How does super() work in constructors?

class Intern extends Employee {
    Intern() {
        // ✘ compile error: constructor Employee in class Employee cannot be applied to given types
    }
}

Constructors always run from the top down

Every constructor first hands off to its parent, all the way up to Object. Then they finish in order from parent to child:

class A { A() { System.out.println("A built"); } }
class B extends A { B() { System.out.println("B built"); } }    // implicit super()
class C extends B { C() { System.out.println("C built"); } }    // implicit super()

new C();

A built
B built
C built

Rules for using super

super vs this: what's the difference?

Quick recap

What's next?

Learn what happens when something belongs to the class instead of an object, in the static keyword guide, or review this.