Favor composition over inheritance — why?

Direct Answer

'Favor composition over inheritance' is a guideline for reuse, not a rule that composition is always better. Composition can keep dependencies explicit and limit exposure to base-class internals. It is most helpful when behavior is optional or replaceable. Inheritance remains suitable for a stable, documented subtype or framework extension point.

Code Example

interface Notifier {
    void send(String message);
}

final class OrderService {
    private final Notifier notifier;

    OrderService(Notifier notifier) {
        this.notifier = notifier;
    }

    void placeOrder() {
        // Save the order, then notify the customer.
        notifier.send("Order placed");
    }
}

OrderService service = new OrderService(new EmailNotifier());

The collaborator is selected when OrderService is created. Production can provide EmailNotifier, while a focused test can provide a fake. This is a useful seam, not a promise that the same service object can hot-swap its notifier later.

Common Mistakes & Pitfalls

• Treating composition as automatically loose: the declared collaborator contract decides the coupling.
• Saying inherited code cannot be tested: inheritance may be tested directly or through a controlled subclass.
• Creating an interface only for a mock framework mock: a simple real collaborator or fake may be clearer.
• Rejecting every inheritance hierarchy: supported subtypes and framework extension points remain valid.
• Assuming dependencies must change at runtime: selecting an implementation at object creation is often enough.