Constructors and super

Written Explanation

Constructors belong to one class

A constructor's job is to put a new object into a valid first state. Account(String owner, double balance) knows how to do that for an Account. A SavingsAccount has an extra field, rate, which the Account constructor knows nothing about. So constructors are not inherited: each class writes its own.

But the parent part still has to be set up properly, with the parent's rules. The subclass constructor therefore asks the parent's constructor to do it.

super(...): calling the parent constructor

Inside a subclass constructor, super(arguments) calls a constructor of the direct superclass:

SavingsAccount(String owner, double balance, double rate) {
    super(owner, balance);   // build the Account part
    this.rate = rate;        // then build the SavingsAccount part
}

The arguments decide which parent constructor runs, exactly as with new: super(owner, balance) matches Account(String, double).

The Java tutorial states the key rule: a call to a superclass constructor must be the first line of the subclass constructor. Putting anything before it is a compile-time error. This guarantees the parent part exists before the child part uses it.

The order of construction

When you create a Puppy that extends Dog that extends Animal, the constructors run from the top of the chain down. The tutorial describes this as constructor chaining that goes up the hierarchy until it reaches Object's constructor; what that means for you is: parent first, child last.

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

class Dog extends Animal {
    Dog() { System.out.println("2. Dog part built"); }
}

class Puppy extends Dog {
    Puppy() { System.out.println("3. Puppy part built"); }
}

new Puppy() prints:

1. Animal part built
2. Dog part built
3. Puppy part built

Notice that Dog() and Puppy() never wrote super(). Java did it for them.

What Java inserts when you write nothing

If a constructor does not start with super(...) (or this(...)), the compiler inserts a call to the parent's no-argument constructor, super(). Two cases follow:

1. The parent has a no-argument constructor (a class with no constructors at all gets a default one): everything works silently, as in the Puppy example.
2. The parent has constructors but none without parameters: the implicit super() has nothing to call, and the compiler reports an error.

Here is case 2. Account only has Account(String, double), and the subclass constructor forgets super(...):

class SavingsAccount extends Account {
    private double rate;

    SavingsAccount(String owner, double rate) {
        this.rate = rate;
    }
}

Compiling with JDK 21 gives:

Main.java:14: error: constructor Account in class Account cannot be applied to given types;
    SavingsAccount(String owner, double rate) {
                                              ^
  required: String,double
  found:    no arguments
  reason: actual and formal argument lists differ in length

Read it as: "you are building an Account, and you did not tell it the String and double it requires." The fix is to add super(owner, 0); (or take a balance parameter) as the first line.

The same message appears when a class has no constructor at all but its parent has no no-argument constructor, because the compiler-provided default constructor also calls super().

Constructors can still chain with this(...)

From the previous module you know this(...) calls another constructor of the same class. It also must be the first statement, so a constructor uses either this(...) or super(...), not both. The chain ends at a constructor that calls super(...):

SavingsAccount(String owner, double balance, double rate) {
    super(owner, balance);
    this.rate = rate;
}

SavingsAccount(String owner, double rate) {
    this(owner, 0, rate);     // reuse the constructor above
}

super.method(): the parent's version

super followed by a dot and a method name calls the parent's version of a method. You use it when the child wants to add to the parent's behavior instead of replacing it. Suppose Account has describe() and SavingsAccount declares its own describe() with the same signature:

String describe() {
    return super.describe() + " (rate " + rate + ")";
}

This is called overriding, the subject of the next lesson. Here, just see the tool: super.describe() runs the code written in Account, then the child appends its own text.

A fine point to keep: super(...) with parentheses is a constructor call that can appear only as the first statement of a constructor. super.name(...) with a dot is a method call that can appear anywhere in an instance method.

A note about Java versions

The "first statement" rule is the rule in the Java versions this course uses. Newer Java releases have been relaxing what may appear before super(...). Do not rely on that in beginner code: keep super(...) as the first line.