Composition vs Inheritance — Why 'Favor Composition Over Inheritance'

Composition and inheritance are two fundamental approaches to code reuse and behavioral flexibility in Java. Inheritance uses extends to acquire a parent's implementation — but it also creates a permanent coupling to every implementation detail of that parent. Composition instead holds behavior through interface references, which makes it loosely coupled, swappable at runtime, and straightforward to test.

The fragile base class problem:

• When a child class extends a parent, it silently inherits every dependency and behavior of that parent — change the parent's internals and children break, often in ways that aren't immediately obvious
• Java's Stack extends Vector is the canonical mistake: Stack inherited insertElementAt() and removeElementAt(), which permanently violate the LIFO contract — callers can insert at position 3 of a "stack"
• The Javadoc still says to use Deque instead; the class can't be fixed without breaking backward compatibility — that's how permanent the coupling is

Why composition is more flexible:

• Composition holds behavior via an interface reference — ReportGenerator has a ReportFormatter field — which means you can inject PdfFormatter, CsvFormatter, or ExcelFormatter without creating a new subclass for each
• Adding new capabilities (logging, retry, auditing) means injecting more collaborators as separate fields, not extending deeper into a class hierarchy
• Composed dependencies can be mocked in isolation — unit testing a class that extends requires testing all parent behavior too; composition lets you test each piece independently

When inheritance is the right choice:

• Genuine IS-A with a permanent relationship that will never need swapping: Dog extends Animal is appropriate if Dog really is an Animal in every context
• Template method pattern: the parent defines the algorithm skeleton and subclasses fill in well-defined abstract steps — a clean use of inheritance with clear boundaries

I recommend defaulting to composition. Reach for inheritance only when the IS-A relationship is genuine and permanent, and behavior never needs to be swapped at runtime.