Inheritance and Polymorphism

1extends and Single Inheritance

A class can extend exactly one superclass (Java has no multiple class inheritance, unlike C++). Every class that doesn't explicitly extend anything implicitly extends Object.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
    String speak() { return name + " makes a sound"; }
}

class Dog extends Animal {
    Dog(String name) { super(name); } // must call a superclass constructor first
    @Override
    String speak() { return name + " barks"; }
}

Animal a = new Dog("Rex");
System.out.println(a.speak()); // "Rex barks" — the OVERRIDE runs, even though `a` is typed Animal

2super — Calling Up the Chain

super(...) calls a superclass constructor and must be the first statement in a subclass constructor (if you don't write it, the compiler inserts an implicit super() — the no-arg version — which fails to compile if the superclass has no no-arg constructor). super.method() calls the superclass's version of an overridden method explicitly.

class Cat extends Animal {
    Cat(String name) { super(name); }
    @Override
    String speak() {
        return super.speak() + ", specifically a meow"; // extends rather than replaces the parent behavior
    }
}

3Method Overriding Rules

An override must have the same signature (name + parameter types), a covariant or identical return type, and cannot narrow the declared checked exceptions or reduce visibility. @Override is optional but strongly recommended — it makes the compiler verify you actually matched a superclass method, catching typos that would otherwise silently create an unrelated overload instead of an override.

class Shape {
    Shape self() { return this; }
    void resize(int factor) throws Exception { }
}

class Circle extends Shape {
    @Override
    Circle self() { return this; }         // covariant return type: Circle is-a Shape — allowed
    @Override
    void resize(int factor) { }              // narrowing (dropping) a checked exception is allowed
    // void resize(int factor) throws IOException {} // ERROR if not declared by the superclass — cannot WIDEN
}

4Fields Are Not Polymorphic — Only Methods Are

This is one of the most important and most surprising rules in the language: field access is resolved by the declared (compile-time) type of the reference, not the runtime type of the object. Overriding only applies to methods.

class Base { String label = "base"; }
class Derived extends Base { String label = "derived"; }

Base b = new Derived();
System.out.println(b.label);            // "base" — field access uses the DECLARED type
System.out.println(((Derived) b).label); // "derived" — only visible after an explicit cast

5Abstract Classes

An abstract class cannot be instantiated and may declare methods with no body (abstract methods) that subclasses are forced to implement.

abstract class Shape {
    abstract double area();                    // no body — subclasses MUST implement
    String describe() { return "area=" + area(); } // concrete method, can call the abstract one
}

class Square extends Shape {
    double side;
    Square(double side) { this.side = side; }
    @Override
    double area() { return side * side; }
}

6Interfaces

An interface defines a contract; a class can implement any number of interfaces (this is Java's answer to the lack of multiple class inheritance). Since Java 8, interfaces may also provide default method bodies and static methods.

interface Movable {
    void move(int dx, int dy);

    default String describeMovement() { // default method — concrete, inherited unless overridden
        return "can move";
    }
}

interface Drawable {
    void draw();
}

class Sprite implements Movable, Drawable {
    public void move(int dx, int dy) { /* ... */ }
    public void draw() { /* ... */ }
}

7Object's Methods: equals, hashCode, toString

Every class inherits equals, hashCode, and toString from Object. The defaults are reference-identity based and rarely what you want for value-like classes.

class Point {
    int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point p)) return false; // pattern-matching instanceof, Java 16+
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return java.util.Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }
}

⚠️ Common Pitfalls

1. Calling an overridable method from a constructor — the superclass constructor runs before subclass field initializers, so an overridden method invoked mid-construction can observe uninitialized subclass state (see the OOP Fundamentals topic's "Under the Hood" for exactly why: invokespecial for the constructor happens first, but the vtable slot for the overridden method already points at the subclass's version).
2. Overriding equals() without hashCode() (or vice versa) — violates the contract that equal objects must have equal hash codes, silently breaking HashMap/HashSet lookups (see the Collections Framework topic) even though nothing throws an exception.
3. Assuming fields are polymorphic like methods — base.label in section 4 resolves by declared type, not runtime type; this trips up anyone coming from a language where all member access is virtual.
4. Accidentally overloading instead of overriding — a subtle signature mismatch (wrong parameter type, missing/extra parameter) creates a brand-new overload rather than an override, and without @Override the compiler won't warn you; the superclass version silently keeps running for callers using the superclass type.
5. Widening a checked exception in an override — a subclass override may only throw the same, narrower, or no checked exceptions than the method it overrides — never a broader or unrelated checked exception — because callers coded against the superclass type never expect it.

📋 Quick Reference

class Dog extends Animal {                 // single inheritance only
    Dog(String name) { super(name); }      // super(...) must be first statement
    @Override String speak() { ... }        // @Override catches signature mismatches
}

interface Movable {                          // multiple interfaces allowed
    void move(int dx, int dy);
    default String info() { return "..."; } // Java 8+ default method
}

abstract class Shape {                       // cannot instantiate directly
    abstract double area();                  // subclass MUST implement
}

Base b = new Derived();
b.overriddenMethod();  // Derived's version  — methods: runtime type wins
b.field;                 // Base's version     — fields: declared type wins

// Object contract: override equals + hashCode together, always

🎤 Interview Q&A

🛠️ Practice exercises

Each exercise is a file in this topic folder. Code exercises are self-checking: run them and make the checks pass.

Source: java_inheritance_and_polymorphism_theory.md · generated by tools/build_lessons.py