Design Patterns Quick Reference

This page is organized the same way the Gang of Four organized their catalog: Creational patterns control how objects get built, Structural patterns control how objects are composed into larger structures, and Behavioral patterns control how objects communicate and distribute responsibility. Rather than memorizing UML diagrams, the fastest way to use a cheat sheet like this is to memorize the trigger — the specific force or symptom in your code that should make a pattern come to mind — because in real work you start from a problem, not a pattern name, and need to search your memory by symptom.

Singleton ensures a class has exactly one instance and provides a global access point — trigger: you need exactly one shared coordinator, like a configuration manager, but beware the testability cost. Factory Method lets a superclass defer instantiation to subclasses — trigger: a base class needs to create an object but doesn't know the concrete type until a subclass specifies it. Abstract Factory produces families of related objects without specifying concrete classes — trigger: you need to guarantee a set of related products (e.g., a UI theme's button, checkbox, and scrollbar) are used together consistently. Builder separates the construction of a complex object from its representation — trigger: a constructor would otherwise need many optional parameters, causing a 'telescoping constructor' problem. Prototype creates new objects by cloning an existing instance — trigger: object creation is expensive and an existing configured instance is a cheaper starting point than building from scratch.

Among structural patterns: Adapter converts one class's interface into another interface clients expect (trigger: integrating a third-party library with an incompatible API); Decorator attaches additional responsibilities to an object dynamically (trigger: you need optional, stackable behavior without an explosion of subclasses); Facade provides a simplified interface to a complex subsystem (trigger: clients shouldn't need to know about five interacting classes just to perform one common task); Composite treats individual objects and compositions of objects uniformly (trigger: a tree structure where clients shouldn't care if a node is a leaf or a branch). Among behavioral patterns: Observer notifies dependents automatically when a subject's state changes (trigger: one-to-many state-dependent updates); Strategy makes an algorithm interchangeable at runtime (trigger: multiple ways to do the same task that need to be swappable); Command encapsulates a request as an object (trigger: you need undo/redo, queuing, or logging of operations); Template Method defines an algorithm's skeleton in a base class while letting subclasses override specific steps (trigger: several algorithms share the same overall structure but differ in specific steps).

Patterns are rarely used in isolation in production systems; certain combinations recur because they solve adjacent, commonly co-occurring problems. Composite plus Visitor is common in tree-structured data like ASTs or file systems, where Composite provides the uniform tree traversal interface and Visitor adds new operations (like a linter's rule check) without modifying the node classes. Factory Method plus Singleton appears constantly in framework object pools and dependency injection containers, where the factory both constructs and caches the instance. Observer plus Command shows up in undo-capable GUI applications, where user actions become Command objects that notify Observer-based UI components to refresh once executed. Recognizing these pairings speeds up both reading unfamiliar codebases and designing new systems, because you can predict the second pattern once you spot the first.