When to use inheritance — valid use cases

Direct Answer

Inheritance is appropriate when the child satisfies a stable behavioral subtype contract and the parent is intentionally designed for extension. Useful cases include a small abstract base with documented template hooks or a framework base class meant to be subclassed. A real-world 'is-a' sentence, percentage of reused code, or fixed hierarchy depth is not enough by itself.

Code Example

abstract class Shape {
    abstract double area();

    String describe() {
        return "area=" + area();
    }
}

final class Circle extends Shape {
    private final double radius;

    Circle(double radius) {
        if (radius < 0) throw new IllegalArgumentException("radius");
        this.radius = radius;
    }

    @Override double area() {
        return Math.PI * radius * radius;
    }
}

void printArea(Shape shape) {
    System.out.println(shape.describe());
}

printArea(new Circle(2));

This inheritance is useful because callers need the Shape contract and Circle preserves its rules. The class names alone do not prove the design; the contract does.

Common Mistakes & Pitfalls

• Using taxonomic is-a as proof: behavioral substitution is the stronger test.
• Quoting a fixed safe hierarchy depth: complexity depends on contracts and change rate, not a universal number.
• Extending a class only for helper methods: that creates a misleading subtype.
• Subclassing a class not designed for it: undocumented self-calls and protected state can be fragile.
• Rejecting every inheritance use: stable abstract bases and framework extension points can be appropriate.