Inheritance: extends, super, and overriding

Inheritance: building on a class

• Inheritance lets one class reuse another class's fields and methods.
• The class you build on is the superclass (parent); the new class is the subclass (child).
• A subclass is-a kind of its superclass: a Dog is an Animal.

extends and super

• Write class Dog extends Animal to make Dog a subclass of Animal.
• Dog automatically gets every public method of Animal, like getName().
• The subclass constructor calls the superclass constructor first with super(...).

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex");
        System.out.println(d.getName());   // Rex   (inherited from Animal)
        System.out.println(d.speak());     // Woof  (Dog's own version)
    }
}

class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return this.name; }
    public String speak() { return "some sound"; }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);          // run Animal's constructor
    }
    public String speak() {   // override Animal's speak()
        return "Woof";
    }
}

Overriding a method

• A subclass can override an inherited method: give it the same signature, a new body.
• Dog's speak() replaces Animal's speak() for Dog objects.
• Methods it does not override (like getName()) are still inherited unchanged.

super.method() — extend, don't replace

• Sometimes you want the parent's work plus a little more.
• Inside an override, super.describe() runs the superclass version of the method.
• Then you add to its result instead of rewriting it from scratch.

public class Main {
    public static void main(String[] args) {
        Bird b = new Bird("Tweety");
        System.out.println(b.describe());
        // I am an animal named Tweety, and I can fly
    }
}

class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String describe() { return "I am an animal named " + this.name; }
}

class Bird extends Animal {
    public Bird(String name) { super(name); }
    public String describe() {
        return super.describe() + ", and I can fly";   // reuse, then add
    }
}

is-a: a subclass fits where its superclass is expected

• Because a Dog is an Animal, you can write Animal a = new Dog("Spot");.
• The variable's type is Animal, but the object is really a Dog.
• This "is-a" rule is what makes the next lesson — polymorphism — possible.

Common mistakes

• super(...) must be the first line of a subclass constructor.
• Add @Override so the compiler catches a wrong signature.

Now you try

• Each task gives you a finished Animal superclass. Write or complete the subclass below it.
• A hidden Harness builds your object and checks both inherited and new behaviour.
• Press Run to compile, then Check answer. Your code runs on the server, so even the first run is fast.