Gang of Four Design Patterns: What They Solve

Ensure a class has only one instance and provide a single global point of access to it.

Define an interface for creating an object, but let subclasses decide which concrete class to instantiate.

Create families of related or dependent objects without specifying their concrete classes.

Separate the construction of a complex object from its representation so the same process can create different representations.

Create new objects by copying (cloning) an existing instance rather than instantiating a class.

Convert the interface of a class into another interface that clients expect, letting incompatible interfaces work together.

Decouple an abstraction from its implementation so the two can vary independently.

Compose objects into tree structures and let clients treat individual objects and compositions uniformly.

Attach additional responsibilities to an object dynamically without changing its class.

Provide a unified, simplified interface to a complex subsystem.

Use sharing to support large numbers of fine-grained objects efficiently by minimizing memory.

Provide a placeholder or surrogate for another object to control access to it.

Pass a request along a chain of handlers until one of them handles it, decoupling sender from receiver.

Encapsulate a request as an object, allowing it to be queued, logged, parameterized, or undone.

Define a grammar for a language and an interpreter that evaluates sentences in that language.

Provide a way to access elements of a collection sequentially without exposing its underlying representation.

Define an object that encapsulates how a set of objects interact, reducing direct coupling between them.

Capture and externalize an object's internal state so it can be restored later, without violating encapsulation.

Notify and update dependent objects automatically when one object changes state (one-to-many dependency).

Allow an object to alter its behavior when its internal state changes, appearing to change its class.

Define a family of interchangeable algorithms, encapsulate each one, and make them swappable at runtime.

Define the skeleton of an algorithm in a method, deferring some steps to subclasses.

Add new operations to an object structure without modifying the classes of the elements it operates on.