Creational design patterns are concerned with the process of object creation. They provide various ways to create objects while hiding the complexities of the instantiation process.
Ensures a class has only one instance and provides a global point of access to it.
Defines an interface for creating objects, but lets subclasses decide which class to instantiate.
Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
Separates the construction of a complex object from its representation, allowing the same construction process to create different objects.
Creates new objects by copying an existing object, known as a prototype.
</br>
Structural design patterns are concerned with how objects and classes are composed to form larger structures, how we establish relationships between the entities for that.
Converts one interface to another, allowing incompatible interfaces to work together.
Decouples an abstraction from its implementation, enabling them to vary independently.
Composes objects into tree structures to represent part-whole hierarchies.
Adds responsibilities to an object dynamically without altering its structure.
Provides a simplified interface to a complex system of classes.
Reduces memory usage by sharing common parts of objects, making large numbers of fine-grained objects more efficient.
Controls access to another object, providing additional functionality like lazy initialization or security.
</br>
Behavioral patterns are concerned with managing algorithms, relationships, and responsibilities between objects, ensuring that objects communicate effectively and efficiently to perform tasks.
Passes a request along a chain of handlers.
Encapsulates a request as an object.
Interprets sentences in a language.
Provides a way to traverse a collection without exposing its underlying representation.
Defines communication between objects to reduce direct interactions.
Saves and restores an object’s state.
Notifies dependent objects of state changes.
Changes an object’s behavior when its state changes.
Allows the selection of an algorithm at runtime.
Defines the structure of an algorithm but lets subclasses modify certain steps.
Adds new operations to a class without changing it.