Composition Over Inheritance: Prefer Has-A Over Is-A

Deep inheritance hierarchies are rigid: a change to a base class ripples down to all subclasses. Subclasses inherit all methods including ones they don't need, and multiple inheritance is impossible in most languages.

Build behavior by composing small, focused objects rather than extending a base class. Type the composed parts as interfaces so they can be swapped.

// Inheritance: fragile and inflexible
class Animal {
  breathe() {}
  move() {}
}
class FlyingAnimal extends Animal { fly() {} }
class SwimmingAnimal extends Animal { swim() {} }
// DuckAnimal needs both fly() and swim() — impossible without multiple inheritance

// Composition: mix any combination
interface Flyable { fly(): void; }
interface Swimmable { swim(): void; }
interface Walkable { walk(): void; }

const canFly: Flyable = { fly: () => console.log('flying') };
const canSwim: Swimmable = { swim: () => console.log('swimming') };

type Duck = Flyable & Swimmable & Walkable;
const duck: Duck = {
  ...canFly,
  ...canSwim,
  walk: () => console.log('waddling'),
};

// Or via class composition
class DuckService {
  constructor(
    private flier: Flyable,
    private swimmer: Swimmable
  ) {}
  act() { this.flier.fly(); this.swimmer.swim(); }
}

Composition is more flexible than inheritance because composed parts can be swapped at runtime, mixed in any combination, and changed independently. TypeScript's structural typing and interface intersection types make composition idiomatic.