Gangs of Four (GoF) Design Patterns

Overview

Creational

Deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. These patterns help in making a system independent of how its objects are created, composed, and represented.

Name	Visualization	Definition	Example
Singleton		ensures a class has only one instance and provides a global point of access to it	database connection manager in a web application
Factory		interface for creating objects in a superclass but allows subclasses to alter the type of objects that will be created implementation via inheritance creates 1 product	different factories produce different types of vehicles (car, truck)
Abstract Factory		interface for creating families of related or dependent objects without specifying their concrete classes implementation via composition creates families of the products	GUI toolkit providing different look and feel for different operating systems
Builder		separates the construction of a complex object from its representation, allowing the same construction process to create various representations constructs complex objects step by step	construction of complex objects like HTML documents
Prototype		specifies the kinds of objects to create using a prototypical instance, and creates new objects by copying this prototype creates a copy (clone) of an object	creating multiple instances of a document (cloning objects) with different content but similar structure

Factory vs Abstract Factory

Aspect	Factory Method	Abstract Factory
Product Type	creates one product only	creates families of related or dependent products
Exposure	exposes a method to create the object	exposes a family of related objects
Construction Hiding	hides the construction of a single object	hides the construction of a family of related objects. Abstract factories are usually implemented using (a set of) factory methods
Creation Responsibility	uses inheritance and relies on a derived class or subclass to create an object	uses composition to delegate the responsibility of creating an object to another class
Ideal Usage	best for cases where the client doesn't know what concrete classes it will be required to create at runtime	best utilized when your system has to create multiple families of products or you want to provide a library of products without exposing the implementation details

Structural

Focus on organizing different classes and objects to form larger structures and provide new functionality. They help ensure that if one part of a system changes, the entire system doesn't need to do so. These patterns generally identify simple ways to realize relationships between entities.

Name	Visualization	Definition	Example
Adapter		allows objects with incompatible interfaces to collaborate (adapt incompatible interfaces) acts as a wrapper	adapting an old version of an API to a new version
Bridge		decouples an abstraction from its implementation so that the 2 can vary independently	Different rendering engines (DirectX, OpenGL) for graphical shapes in a drawing application
Composite		composes objects into tree structures to represent part-whole hierarchies composes zero-or-more similar objects so that they can be manipulated as one object	representing a hierarchy of files and directories in a file system
Decorator		attaches additional responsibilities to an object dynamically, providing a flexible alternative to subclassing	adding additional features to a text editor, such as spell checking or formatting
Facade		provides a simplified interface to a complex system of classes, libraries, or frameworks defines a high-level interface that makes the subsystem easier to use	providing a simplified interface to a complex subsystem like a software library
Flyweight		shares common state among multiple objects, effectively reducing memory consumption reduces the cost of creating and manipulating a large number of similar objects	text editing software where frequently used characters (space, period) are stored as flyweight objects to save memory
Proxy		provides a surrogate or placeholder for another object to control access to it	proxy server that acts as an intermediary between clients and a web server, handling requests and caching responses

Behavioral

Concentrate on algorithms and the assignment of responsibilities between objects. They describe not just patterns of objects or classes but also the patterns of communication between them. These patterns help in defining how objects interact and communicate with each other.

Name	Visualization	Definition	Example
Chain of Responsibility		passes requests along a chain of handlers, allowing multiple objects to handle a request without the sender needing to know which object will ultimately process it	handling support tickets in a customer service system where tickets are passed down a chain of support agents until one can handle it
Command		encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations	undo and redo operations in a text editor
Interpreter		defines a grammatical representation for a language and provides an interpreter to interpret sentences in the language	implementing a query language interpreter for a database system to parse and execute user queries
Iterator		provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation	iterating through a collection of objects in a database system
Mediator		defines an object that encapsulates how a set of objects interact, promoting loose coupling by keeping objects from referring to each other explicitly	chat application where users communicate through a central chat room (mediator) rather than directly with each other
Memento		captures and externalizes an object's internal state so that the object can be restored to this state later	saving and restoring the state of a text editor (cursor position, selected text) to implement undo/redo functionality
Observer		defines a one-to-many dependency between objects, so that when one object changes state, all its dependents are notified and updated automatically	updating the GUI when the contents of a text editor change
State		allows an object to alter its behavior when its internal state changes, encapsulating state-specific behavior into separate objects	switching between different views of a text editor (normal, bold, italic). Deals with what (state or type) an object is (in). It encapsulates state-dependent behavior
Strategy		defines a family of algorithms, encapsulates each one, and makes them interchangeable allows the algorithm to vary independently from clients that use it use Composition over Inheritance	switching between different sorting algorithms (quicksort, mergesort, heapsort). Deals with how an object performs a certain task. It encapsulates an algorithm
Template Method		defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps of the algorithm without changing its structure	creating a new type of text editor (text editor with spell checking)
Visitor		represents an operation to be performed on elements of an object structure, decoupling the algorithm from the object structure	compiler that traverses an abstract syntax tree representing code and performs different operations (type checking, code generation) based on the node being visited

State vs Strategy

Aspect	State	Strategy
Storage of Context Object Reference	store a reference to the context object that contains them	do not store
Replacement Ability	are allowed to replace themselves, changing the state of the context object	cannot replace themselves or change the state of the context object
Creation	created by the context object itself	passed to the context object as parameters
Responsibility	provide the underlying implementation for most actions of the context object	handle specific tasks but do not dictate the behavior of the context object
Focus	deals with what (state or type) an object is (in). It encapsulates state-dependent behavior	deals with how an object performs a certain task. It encapsulates an algorithm