Why is composition often preferred over inheritance?

Question

Accepted Answer

**Composition over inheritance** is a widely-cited design principle — favoring building objects by **combining behaviors** (composition) rather than inheriting from base classes (inheritance). Inheritance has significant drawbacks that composition avoids, though both have their place.

## Inheritance vs composition

```text
INHERITANCE → a class EXTENDS another, inheriting its behavior ("IS-A" relationship):
  class Dog extends Animal
COMPOSITION → a class is BUILT FROM other objects/behaviors ("HAS-A" / uses):
  class Car { constructor() { this.engine = new Engine(); } }   // composes behaviors
→ composition: combine smaller pieces; inheritance: derive from a parent
```

## Why inheritance has problems

```text
✗ TIGHT COUPLING → subclasses are tightly bound to their parent's implementation (changes
  to the parent can break subclasses — the "fragile base class" problem)
✗ RIGID hierarchies → deep/wide inheritance trees become hard to change and understand
✗ Inflexible → a class can usually only inherit from ONE parent; behavior is fixed at compile
  time; hard to combine behaviors from multiple sources
✗ Forces an "IS-A" relationship that may not truly hold; exposes parent internals
```

## Why composition is often better

```text
✓ FLEXIBLE → compose behaviors as needed; combine multiple behaviors; change at RUNTIME
✓ LOOSE COUPLING → objects depend on interfaces of composed parts, not parent implementations
✓ REUSABLE → small, focused components reused in many combinations
✓ Easier to change/test; avoids fragile hierarchies; favors small, focused pieces
→ many patterns (Strategy, Decorator) use composition; "favor composition over inheritance"
  ⚠️ inheritance still has valid uses (true IS-A, sharing interface) → use it appropriately
```

## Why it matters

Understanding why composition is often preferred over inheritance is valuable senior-level knowledge because it's a **fundamental design principle** that improves flexibility and maintainability, reflecting mature design judgment.

The principle "favor composition over inheritance" is widely cited because inheritance, despite being a core OO feature, has significant drawbacks.

Understanding the **distinction** (inheritance as an "IS-A" relationship extending a parent, composition as a "HAS-A" relationship building from other objects) is the foundation.

Understanding **why inheritance has problems** is the key insight: **tight coupling** (subclasses bound to their parent's implementation, with parent changes breaking subclasses — the fragile base class problem), **rigid hierarchies** (deep inheritance trees becoming hard to change and understand), **inflexibility** (typically only single inheritance, behavior fixed at compile time, hard to combine behaviors from multiple sources), and forcing IS-A relationships that may not truly hold.

These are real, significant problems that cause maintenance difficulties.

Understanding **why composition is often better** — **flexibility** (composing and combining behaviors as needed, changing at runtime), **loose coupling** (depending on interfaces of composed parts rather than parent implementations), **reusability** (small, focused components reused in many combinations), and easier change and testing — explains why composition avoids inheritance's drawbacks.

Recognizing that many patterns (Strategy, Decorator) use composition, while inheritance still has valid uses (true IS-A relationships, sharing interfaces), reflects balanced judgment — composition is *often* preferred, but inheritance has its place.

This principle is fundamental to flexible, maintainable design.

Since "favor composition over inheritance" is a fundamental, widely-cited design principle, and since understanding inheritance's real drawbacks (coupling, rigidity, inflexibility) and composition's benefits (flexibility, loose coupling, reusability) — while recognizing inheritance's valid uses — reflects mature design judgment that improves code, understanding why composition is often preferred over inheritance is valuable senior-level knowledge — a fundamental design principle for flexible, maintainable code, underlying many patterns, and reflecting the mature design judgment (favoring composition while knowing inheritance's place) expected of senior developers writing well-designed object-oriented software.