super Keyword

super(...) — Calling the Superclass Constructor

super(...) invokes a constructor of the immediate superclass, and if used, it must be the first statement inside the subclass constructor — the compiler rejects any code before it, for the same reason this(...) must come first. If a subclass constructor does not explicitly call super(...), Java automatically inserts a call to the superclass's no-argument constructor as the first statement. If the superclass has no no-argument constructor available, the subclass is then required to call super(...) explicitly with matching arguments, or the code fails to compile.

super.field and super.method() — Accessing Hidden or Overridden Members

super.fieldName accesses a field defined in the superclass, which is useful when a subclass declares a field with the same name (field hiding). super.methodName() calls the superclass's version of a method even when the subclass has overridden that method — this is commonly used inside an overriding method to extend, rather than completely replace, the parent's behavior.

• super(...) must be the first statement in a constructor, exactly like this(...).
• A constructor cannot contain both this(...) and super(...) — only one first statement is allowed.
• super.method() is often used inside an override to run the parent behavior and then add subclass-specific logic.

super.variable and Field Hiding

Methods are overridden, but fields are not. If Dog declares a field type and Animal already has one with the same name, a Dog object holds two separate fields. Inside Dog, plain type and this.type mean the dog's field, and super.type reaches the one declared in Animal. Which field you get depends on the declared type of the reference, not the real object: through an Animal variable you see Animal's field even when the object is a Dog. That is the opposite of how overridden methods behave, and it is why field hiding is best avoided in real code. Give the field a different name, or make it private and expose it through a method.

Constructor Chaining Up the Hierarchy

Every constructor starts by running a constructor of its parent, either the one you name with super(...) or, when you write nothing, the parent's no-argument constructor that the compiler inserts for you. That parent constructor in turn calls its own parent, all the way up to Object. The result is that constructors run from the top of the hierarchy down: for Puppy extends Dog extends Animal, creating a Puppy prints Animal(), then Dog(), then Puppy(). This order guarantees that the parent's fields are set up before the child's constructor body can use them.

What super Cannot Do

• It cannot be used in a static method or static block. There is no current object there, so the compiler reports non-static variable super cannot be referenced from a static context.
• It cannot skip a level: super.super.method() is not valid Java. A class can only reach its immediate parent; if the grandparent's behaviour is needed, the parent has to expose it.
• It cannot reach private members of the parent. super.secret fails to compile when secret is private, just as it would without super.

Examples

class Animal {
    String name;

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

    void makeSound() {
        System.out.println(name + " makes a generic animal sound");
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // must be first statement
    }

    @Override
    void makeSound() {
        super.makeSound(); // run the parent version first
        System.out.println(name + " barks");
    }

    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        d.makeSound();
    }
}

Rex makes a generic animal sound
Rex barks

public class SuperDemo {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        System.out.println("---");
        d.describe();
        System.out.println("---");
        d.makeSound();
    }
}

class Animal {
    String name;
    String type = "animal";

    Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor: " + name);
    }

    void makeSound() {
        System.out.println(name + " makes a sound");
    }
}

class Dog extends Animal {
    String type = "dog";          // hides Animal.type

    Dog(String name) {
        super(name);              // runs Animal(String) first
        System.out.println("Dog constructor: " + name);
    }

    void describe() {
        System.out.println("type       = " + type);
        System.out.println("this.type  = " + this.type);
        System.out.println("super.type = " + super.type);
        Animal asAnimal = this;
        System.out.println("((Animal) this).type = " + asAnimal.type);
    }

    @Override
    void makeSound() {
        super.makeSound();        // parent's version first
        System.out.println(name + " barks");
    }
}

Animal constructor: Rex
Dog constructor: Rex
---
type       = dog
this.type  = dog
super.type = animal
((Animal) this).type = animal
---
Rex makes a sound
Rex barks

public class Chain {
    public static void main(String[] args) {
        new Puppy();
    }
}

class Animal {
    Animal() { System.out.println("1. Animal()"); }
}

class Dog extends Animal {
    Dog() { System.out.println("2. Dog()"); }          // compiler inserts super();
}

class Puppy extends Dog {
    Puppy() {
        super();                                        // explicit, same effect
        System.out.println("3. Puppy()");
    }
}

1. Animal()
2. Dog()
3. Puppy()

// 1. Parent has no no-argument constructor, child does not call super(...)
class Animal {
    String name;
    Animal(String name) { this.name = name; }
}
class Dog extends Animal {
    Dog() {
        System.out.println("creating a dog");
    }
}

// 2. A statement before super(...)
class Cat extends Animal {
    Cat(String name) {
        if (name.isBlank()) throw new IllegalArgumentException("name required");
        super(name);
    }
}

// 3. super inside a static method
class Bird extends Animal {
    Bird() { super("bird"); }
    static void test() {
        super.toString();
    }
}

1. error: constructor Animal in class Animal cannot be applied to given types;
       Dog() {
             ^
     required: String
     found:    no arguments
     reason: actual and formal argument lists differ in length

2. error: call to super must be first statement in constructor
           super(name);
                ^

3. error: non-static variable super cannot be referenced from a static context
           super.toString();
           ^

Exercise

Complete Manager so that its constructor passes the name to Employee, and its describe() reuses the parent's version and adds (manager).

Expected output: Ravi (manager)

class Employee {
    private final String name;

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

    String describe() {
        return name;
    }
}

class Manager extends Employee {

    Manager(String name) {
        // TODO: pass the name to the Employee constructor
    }

    // TODO: override describe() to return the parent's text plus " (manager)"
}

public class ManagerDemo {
    public static void main(String[] args) {
        System.out.println(new Manager("Ravi").describe());
    }
}

class Employee {
    private final String name;

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

    String describe() {
        return name;
    }
}

class Manager extends Employee {

    Manager(String name) {
        super(name);
    }

    @Override
    String describe() {
        return super.describe() + " (manager)";
    }
}

public class ManagerDemo {
    public static void main(String[] args) {
        System.out.println(new Manager("Ravi").describe()); // Ravi (manager)
    }
}

Quick quiz

Interview questions