Object-Oriented Design Patterns
Object-oriented design patterns implemented in TypeScript, from the book
Design Patterns: Elements of Object-Oriented Sofware
, by Erich Gamma,
Richard Helm, Ralph Johnson, and John Vlissides, also known as the Gang of
Four.
- Abstract Factory Pattern
- The Abstract Factory Pattern is a creational design pattern that enables the creation of families of related objects without specifying their concrete classes, promoting consistency and flexibility.
- Adapter Pattern
- The Adapter Pattern is a structural design pattern that helps incompatible interfaces work together by using an adapter class. This article explains how it works and its benefits in software development.
- Bridge Pattern
- The Bridge Pattern is a structural design pattern that decouples an abstraction from its implementation, enabling flexibility and scalability in software design.
- Builder Pattern
- The Builder Pattern is a creational design pattern that decouples the construction of complex objects from their representation, allowing for flexibility and reuse in object creation.
- Chain of Responsibility Pattern
- The Chain of Responsibility Pattern is a behavioral design pattern that enables a request to be passed along a chain of handlers, allowing for flexible and dynamic processing of requests.
- Command Pattern
- The Command Pattern is a behavioral design pattern that encapsulates requests as objects, enabling parameterization, queuing, and logging of operations for greater flexibility in software design.
- Composite Pattern
- The Composite Pattern is a structural design pattern that enables you to compose objects into tree structures to represent part-whole hierarchies, simplifying the management of complex object structures.
- Decorator Pattern
- The Decorator Pattern is a structural design pattern that enables dynamic addition of behavior to individual objects without modifying their class, promoting flexibility and reusability in software design.
- Facade Pattern
- The Facade Pattern is a structural design pattern that simplifies interactions with complex systems by providing a unified and easy-to-use interface.
- Factory Method Pattern
- The Factory Method Pattern is a creational design pattern that defines an interface for creating objects, allowing subclasses to decide which class to instantiate, promoting flexibility and scalability in object creation.
- Flyweight Pattern
- The Flyweight Pattern is a structural design pattern that reduces memory usage by sharing common parts of objects while maintaining unique variations.
- Interpreter Pattern
- The Interpreter Pattern is a behavioral design pattern that provides a way to evaluate sentences in a language by representing grammar rules as classes.
- Iterator Pattern
- The Iterator Pattern is a behavioral design pattern that allows sequential access to elements of a collection without exposing its internal structure.
- Mediator Pattern
- The Mediator Pattern is a behavioral design pattern that centralizes communication between objects, promoting loose coupling and simplifying interactions.
- Memento Pattern
- The Memento Pattern is a behavioral design pattern that allows capturing and restoring an object’s state, enabling undo functionality and preserving encapsulation.
- Observer Pattern
- The Observer Pattern is a behavioral design pattern that establishes a one-to-many dependency between objects, enabling automatic updates to dependents when the subject’s state changes.
- Prototype Pattern
- The Prototype Pattern is a creational design pattern that facilitates object cloning, enabling the creation of new objects by copying existing ones and promoting flexibility in object creation.
- Proxy Pattern
- The Proxy Pattern is a structural design pattern that provides a surrogate or placeholder for another object, controlling access and adding functionality without modifying the original object.
- Singleton Pattern
- The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance.
- State Pattern
- The State Pattern is a behavioral design pattern that enables an object to change its behavior dynamically based on its internal state, promoting cleaner and more maintainable code.
- Strategy Pattern
- The Strategy Pattern is a behavioral design pattern that allows the selection of algorithms at runtime by encapsulating them in separate classes, promoting flexibility and reusability.
- Template Method Pattern
- The Template Method Pattern is a behavioral design pattern that defines the structure of an algorithm in a base class while allowing subclasses to customize specific steps.
- Visitor Pattern
- The Visitor Pattern is a behavioral design pattern that enables adding new operations to existing object structures without altering their classes, promoting flexibility and maintainability.
[End]