Personal study project for learning the Gang of Four (GoF) design patterns, a design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design.
OOP design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved.
| Design Pattern | Description |
|---|---|
| Abstract Factory | Provides an interface for creating families of related or dependent objects without specifying their concrete classes. |
| Builder | Separates the construction of a complex object from its representation, allowing the same construction process to create different representations. |
| Factory Method | Defines an interface for creating an object but leaves the choice of its type to the subclasses. |
| Prototype | Creates new objects by copying an existing object, known as the prototype. |
| Singleton | Ensures a class has only one instance and provides a global point of access to that instance. |
| Design Pattern | Description |
|---|---|
| Adapter | Allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class. |
| Bridge | Decouples an abstraction from its implementation so that the two can vary independently. |
| Composite | Composes zero-or-more similar objects so that they can be manipulated as one object. |
| Decorator | Dynamically adds/overrides behavior in an existing method of an object. |
| Facade | Provides a simplified interface to a large body of code. |
| Flyweight | Reduces the cost of creating and manipulating a large number of similar objects. |
| Proxy | Provides a placeholder for another object to control access, reduce cost, and reduce complexity. |
| Design Pattern | Description |
|---|---|
| Chain of Responsibility | Delegates commands to a chain of processing objects. |
| Command | Creates objects that encapsulate actions and parameters. |
| Interpreter | Implements a specialized language. |
| Iterator | Accesses the elements of an object sequentially without exposing its underlying representation. |
| Mediator | Allows loose coupling between classes by being the only class that has detailed knowledge of their methods. |
| Memento | Provides the ability to restore an object to its previous state (undo). |
| Observer | Is a publish/subscribe pattern, which allows some observer objects to see an event. |
| State | Allows an object to alter its behavior when its internal state changes. |
| Strategy | Allows one of a family of algorithms to be selected on-the-fly at runtime. |
| Template Method | Defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior. |
| Visitor | Separates an algorithm from an object structure by moving the hierarchy of methods into one object. |
Many other patterns outside the original 23 from the GoF have been developed, I would like to add them to the repository in the future.
Missing patterns:
- Dependency injection
- Lazy initialization
- Multiton
- Object pool
- Resource acquisition is initialization (RAII)
Missing patterns:
- Extension object
- Front controller
- Marker
- Module
- Twin
| Design Pattern | Description |
|---|---|
| Null Object | Provides a surrogate for an actual object, implementing the same interface with no operation or default behavior, to encapsulate the absence of the object. |
Missing patterns:
- Blackboard
- Fluent interface
- Null object
- Servant
- Specification