Factory Method

Hard-coded new behind a type switch

The client function knows about — and constructs — every concrete class itself. Add a platform → edit this function again.

function createButton(os) {
  if (os === 'mac') return new MacButton();
  if (os === 'win') return new WinButton();
  // new platform? edit here again…
  throw new Error('unknown os');
}

Push the decision into a creator subclass

A creator declares a factory method; subclasses override it to return their own product. The client only calls render() — it never names a concrete class.

class Dialog {
  createButton() { /* overridden */ }

  render() {
    const btn = this.createButton();
    btn.render();
  }
}

class MacDialog extends Dialog {
  createButton() { return new MacButton(); }
}
class WinDialog extends Dialog {
  createButton() { return new WinButton(); }
}

Pick a platform — the factory decides the class

The client code never changes. It just calls createButton(); the concrete product that comes back depends on which factory it's talking to.

Construction logic lives in one place

• Decouples the client from concrete product classes — it only knows the interface.
• Open/Closed: a new product = new class + new/registered creator, no client edits.
• Centralizes construction rules that would otherwise be scattered as new calls.
• Careful: don't over-abstract for a single product type — that's YAGNI, a plain constructor is fine.
• Related: a simple factory is just a function with a switch (step 1, minus the pain); Factory Method uses subclass overrides; Abstract Factory creates whole families of related products.