Why is Composition often preferred over Inheritance? (Fragile Base Class problem)

Question

Accepted Answer

Composition is often preferred because it reduces coupling and allows behavior to be changed by replacing collaborators rather than modifying an inheritance hierarchy. The Fragile Base Class problem occurs when a seemingly safe change to a base class unexpectedly changes the behavior of existing subclasses. Subclasses can also depend on implementation details of the parent, making evolution risky. Composition localizes behavior and makes dependencies explicit, which is particularly valuable in large systems. interface PaymentProcessor {
 void process(double amount);
}

class OrderService {
 private final PaymentProcessor processor;

OrderService(PaymentProcessor processor) {
 this.processor = processor;
 }

void checkout(double amount) {
 processor.process(amount);
 }
} Composition reduces inheritance coupling. Dependencies become explicit through constructor injection or similar mechanisms. Components can be replaced without changing the owning class. Composition supports testing through mocks, fakes or alternative implementations. Inheritance remains appropriate when there is a stable and meaningful subtype relationship. The Fragile Base Class problem is a major reason to avoid deep inheritance hierarchies.

Why is Composition often preferred over Inheritance? (Fragile Base Class problem)

Composition Over Inheritance

Scenario Questions

Follow-up Questions