Understanding 23 Classic Design Patterns Through Everyday Analogies

01 Factory Method

Just like ordering chicken wings at fast‑food restaurants, the Factory Method separates the client from the concrete product creation, allowing the client to request a product without knowing its exact class.

02 Builder

The Builder pattern separates a product’s internal representation from its construction process, enabling step‑by‑step creation of complex objects with varying representations.

03 Abstract Factory

Using an abstract factory, clients specify what they need (e.g., a hamburger) while concrete factories decide the exact product variant, decoupling client code from concrete classes.

04 Prototype

Prototype creates new objects by cloning an existing prototype instance, allowing dynamic addition or removal of product types without a rigid class hierarchy.

05 Singleton

Singleton ensures a class has only one instance and provides a global point of access, suitable only when a single shared instance is truly required.

06 Adapter

Adapter converts one interface into another expected by the client, enabling incompatible classes to work together.

07 Bridge

Bridge decouples abstraction from implementation, allowing both to vary independently via composition rather than inheritance.

08 Composite

Composite organizes objects into tree structures so that clients can treat individual objects and compositions uniformly.

09 Decorator

Decorator adds responsibilities to objects dynamically without affecting other instances, offering a flexible alternative to subclassing.

10 Facade

Facade provides a simplified high‑level interface to a complex subsystem, making it easier for clients to use.

11 Flyweight

Flyweight shares common intrinsic state among many fine‑grained objects, separating it from extrinsic state to reduce memory usage.

12 Proxy

Proxy supplies a surrogate object that controls access to the real subject, adding a layer of indirection.

13 Chain of Responsibility

Chain of Responsibility passes a request along a chain of handlers until one handles it, allowing dynamic reconfiguration of responsibility.

14 Command

Command encapsulates a request as an object, separating the invoker from the executor and supporting undoable operations.

15 Interpreter

Interpreter defines a grammar for a language and provides an interpreter to evaluate sentences according to that grammar.

16 Iterator

Iterator provides a way to access elements of an aggregate sequentially without exposing its underlying representation.

17 Mediator

Mediator encapsulates how a set of objects interact, promoting loose coupling by keeping objects from referring to each other directly.

18 Memento

Memento captures and externalizes an object’s internal state so it can be restored later without violating encapsulation.

19 Observer

Observer defines a one‑to‑many dependency so that when a subject changes state, all its observers are automatically notified.

20 State

State allows an object to alter its behavior when its internal state changes, appearing as if the object changed its class.

21 Strategy

Strategy defines a family of algorithms, encapsulates each one, and makes them interchangeable, letting the algorithm vary independently from clients.

22 Template Method

Template Method defines the skeleton of an algorithm in a base class while allowing subclasses to refine specific steps.

23 Visitor

Visitor separates an algorithm from the object structure it operates on, enabling new operations to be added without modifying the elements.