The Visitor Design Pattern Use the Visitor pattern when you need to add further operations to objects without having to modify them. It’s especially useful when dealing with a structure of heterogeneous classes and you need to perform operations that depend on the concrete classes. The Visitor pattern lets you add further operations to objects …
Visitor Design Pattern Read More »
The Strategy Design Pattern Use the Strategy pattern when you want to define a family of algorithms, encapsulate each one of them, and make them interchangeable. Also useful when you want to avoid exposing the complex, algorithm-specific data structures. The Strategy pattern defines a family of algorithms and makes them interchangeable. Type: Behavioral Time Complexity: …
Strategy Design Pattern Read More »
The Template Method Design Pattern Use the Template Method pattern when you want to define the skeleton of an algorithm, letting the subclasses fill in the steps. This is especially useful when the algorithm has invariant steps that are the same across all implementations. The Template Method pattern defines the steps of an algorithm and …
Template Method Design Pattern Read More »
The Singleton Design Pattern Use the Singleton pattern when a class should only have a single instance throughout the entire application, typically for logging, driver objects, caching, thread pools, or database connections. The Singleton pattern ensures that a class has only one instance and provides a global point to access it. Type: Creational Time Complexity: …
Singleton Design Pattern Read More »
The State Design Pattern Use the State pattern when an object’s behavior changes according to its internal state, or when you have an object that manifests different states in complex ways. The State pattern allows an object to alter its behavior when its internal state changes. Type: Behavioral Time Complexity: O(1) Efficiency: 7 Learning Difficulty: …
State Design Pattern Read More »
The Proxy Design Pattern Use the Proxy pattern when you need to control access to an object, either to protect the real object or to control its instantiation and removal. The Proxy pattern provides a surrogate or placeholder for another object to control access to it. Type: Structural Time Complexity: O(1) Efficiency: 7 Learning Difficulty: …
Proxy Design Pattern Read More »
The Observer Design Pattern Use the Observer pattern when a subject needs to notify multiple observers about state changes, or when you want to avoid tight coupling between the subject and its observers. The Observer pattern defines a one-to-many dependency between a subject and multiple observers, allowing the observers to be notified of state changes …
Observer Design Pattern Read More »
The Prototype Design Pattern Use the Prototype pattern when you need to create an object that is similar to an existing object, especially if the cost of creating the object from scratch is more expensive or complex than duplicating an existing one. The Prototype pattern creates new objects by copying an existing object, known as …
Prototype Design Pattern Read More »
The Mediator Design Pattern Use the Mediator pattern when you want to reduce coupling between classes that communicate with each other directly, or when you want to centralize external communications. The Mediator pattern defines an object that encapsulates how a set of objects interact. Type: Behavioral Time Complexity: O(n) Efficiency: 5 Learning Difficulty: average 6.2 …
Mediator Design Pattern Read More »
The Memento Design Pattern Use the Memento pattern when you want to capture and externalize an object’s internal state without violating encapsulation, so the object can be restored to this state later. The Memento pattern provides a way to capture an object’s internal state so that it can be restored later. Type: Behavioral Time Complexity: …
Memento Design Pattern Read More »
