Design Patterns Cheat Sheet

Updated 2026-04-29

Next Topic: Developer Environment Setup and Automation Cheat Sheet

Design patterns are reusable, proven solutions to recurring design problems in software development, cataloged most famously by the Gang of Four (GoF) in their 1994 book. They provide a shared vocabulary for developers to communicate complex design ideas clearly and offer blueprints that improve maintainability, scalability, and testability of object-oriented code. Beyond the original 23 GoF patterns, modern software engineering has produced a rich set of architectural and distributed systems patterns — including CQRS, Event Sourcing, Circuit Breaker, Saga, and Hexagonal Architecture — that address the realities of microservices, cloud-native deployments, and distributed data. Mastering patterns means recognizing when one fits naturally, knowing when to compose multiple patterns together, and understanding that context is everything: the right pattern depends on consistency requirements, team size, language features, and system scale.

What This Cheat Sheet Covers

This topic spans 9 focused tables and 104 indexed concepts. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Creational Patterns — Object ConstructionTable 2: Structural Patterns — Composition and RelationshipsTable 3: Behavioral Patterns — Algorithms and ResponsibilitiesTable 4: Modern and Non-GoF PatternsTable 5: Distributed Systems PatternsTable 6: Pattern Relationships and ComparisonsTable 7: Common Pitfalls and Anti-PatternsTable 8: Pattern Selection GuidelinesTable 9: SOLID Principles and Pattern Support

Table 1: Creational Patterns — Object Construction

Pattern	Example	Description
Singleton	`class Logger {` `private static instance;` `static getInstance() {` `return instance ??= new Logger();` `}` `}`	• Ensures only one instance exists globally • provides a single access point for shared resources like loggers, caches, or configuration objects.
Factory Method	`abstract class Creator {` `abstract createProduct();` `}` `class ConcreteCreator extends Creator {` `createProduct() { return new ProductA(); }` `}`	• Defines an interface for creating objects but lets subclasses decide which concrete class to instantiate • defers instantiation to subclasses.
Abstract Factory	`interface GUIFactory {` `createButton();` `createCheckbox();` `}` `class WindowsFactory implements GUIFactory { ... }`	• Provides an interface for creating families of related objects without specifying concrete classes • ensures all components in a family (e.g., UI components per platform) work together.

Table 1: Creational Patterns — Object Construction

Pattern	Example	Description
Singleton	`class Logger {` `private static instance;` `static getInstance() {` `return instance ??= new Logger();` `}` `}`	• Ensures only one instance exists globally • provides a single access point for shared resources like loggers, caches, or configuration objects.
Factory Method	`abstract class Creator {` `abstract createProduct();` `}` `class ConcreteCreator extends Creator {` `createProduct() { return new ProductA(); }` `}`	• Defines an interface for creating objects but lets subclasses decide which concrete class to instantiate • defers instantiation to subclasses.
Abstract Factory	`interface GUIFactory {` `createButton();` `createCheckbox();` `}` `class WindowsFactory implements GUIFactory { ... }`	• Provides an interface for creating families of related objects without specifying concrete classes • ensures all components in a family (e.g., UI components per platform) work together.