How Does super Work in Java?

super is a reference to the superclass of the current class. It has three distinct uses, and confusing them is a common source of errors.

super(...) is a constructor call. It invokes a constructor of the superclass, and it must be the first statement of the constructor body. If you omit it, the compiler inserts an implicit super() to the superclass's no-argument constructor — which is why a subclass whose superclass has no no-argument constructor fails to compile until you add an explicit super(...) call.

super.field reads a field of the superclass. It matters when the subclass declares a field with the same name: inside the subclass, the unqualified name refers to the subclass's field, and super.field reaches the other one. Note that super.field cannot be used on the left-hand side of an assignment, because assignment to a superclass field through super is not permitted — you have to call a superclass method instead.

super.method() calls the superclass implementation of a method. This is the useful one when you are overriding: you call the parent's version and add behaviour around it, instead of duplicating it.

public class Main {
    public static void main(String[] args) {
        Child child = new Child("Ada");
        System.out.println("name  : " + child.getName());
        System.out.println("label : " + child.describe());
    }
}

class Parent {
    protected String name;

    Parent(String name) {
        this.name = name;
        System.out.println("Parent constructor ran");
    }

    String describe() {
        return "I am the parent";
    }
}

class Child extends Parent {
    private final String label;

    Child(String name) {
        super(name);                       // must be the first statement
        this.label = "child of " + name;
        System.out.println("Child constructor ran");
    }

    @Override
    String describe() {
        return super.describe() + " and I am the child";
    }

    String getName() {
        return name;                      // inherited protected field
    }
}

The output shows both the ordering and the three uses. The parent's constructor runs before the child's, so the inherited name field is already set when the child constructor body executes. The describe override calls the parent implementation with super.describe() and appends its own text rather than replacing it.

Because a subclass object is not fully built until its superclass part is built. Java constructs an object in stages: the memory is allocated, the superclass constructor runs to build the inherited part of the object, and only then does the subclass constructor body run to build the subclass part. Allowing statements before the superclass constructor would mean operating on a half-built object — reading an inherited field that has not been initialised yet, or calling an inherited method that depends on state the superclass constructor has not set. The language removes the possibility rather than trusting you to avoid it.

If you omit the call entirely, the compiler inserts an implicit super() to the superclass's no-argument constructor. That works only if such a constructor exists. If the superclass declares only parameterised constructors, your subclass constructor fails to compile with an error saying that the constructor cannot be applied to the given types, and the fix is to write the super(...) call explicitly.

public class Main {
    public static void main(String[] args) {
        Base b = new Base();
        System.out.println("base    : " + b.describe());

        Derived d = new Derived();
        System.out.println("derived : " + d.describe());
    }
}

class Base {
    int value;

    Base() {
        this.value = 1;
    }

    String describe() {
        return "Base with value " + value;
    }
}

class Derived extends Base {
    Derived() {
        super();                 // the implicit call would happen anyway
        this.value = 2;         // legal: the superclass constructor has already run
    }

    @Override
    String describe() {
        return "Derived with value " + value;
    }
}

The output demonstrates the ordering. The superclass constructor ran first and set value to 1; then the subclass constructor body ran and changed it to 2. The derived object reports 2, because the subclass field assignment happens after the inherited construction is complete.

One related detail: a constructor must call super() or this(...), but never both. If you call this(...), the constructor you delegate to is responsible for calling super(), and the chain eventually reaches Object.