Why is composition often preferred over inheritance?

Subclassing exposes the parent's protected implementation, not just its contract. A change in the parent can break subclasses even when the public API is stable. This is the fragile base class problem. Composition avoids it by holding a reference to a collaborator and delegating explicitly.

public final class Engine {
    public void start() {
        System.out.println("start");
    }
}

public final class Car {
    private final Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.start();
    }
}

When inheritance is still reasonable

• The subtype truly is a specialised version of the parent
• The parent was designed and documented for extension
• The hierarchy is shallow and stable
• Frameworks require a base class, such as some exception or test base types

Composition also makes testing easier because collaborators can be injected. It keeps the public surface small and avoids inheriting methods that do not make sense for the subtype. The Liskov substitution principle is the test: a subtype must be usable anywhere the parent is expected without breaking behaviour.