Specification Pattern

A behavioral pattern that allows an object to alter its behavior when its internal state changes.

A behavioral pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable, allowing the algorithm to vary independently from the clients that use it.

A behavioral pattern that defines the skeleton of an algorithm in an operation, deferring some steps to subclasses.

A behavioral pattern that lets you separate algorithms from the object structure on which it operates, allowing you to add new operations without modifying the existing code.

A creational design pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes.

A structural design pattern that allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces.

A structural pattern that separates an object’s abstraction from its implementation, allowing both to evolve independently.

A creational pattern that allows constructing complex objects step by step. It separates the construction of a complex object from its representation.

A behavioral pattern that passes a request along a chain of handlers. Each handler decides either to process the request or pass it to the next handler in the chain.

A behavioral design pattern that converts a request into a stand-alone object that contains all information about the request.

A structural pattern that allows you to compose objects into tree structures to represent part-whole hierarchies. Clients can treat individual objects and compositions uniformly.

A structural pattern that allows behavior to be added to individual objects, either statically or dynamically, without affecting the behavior of other objects from the same class.

A structural pattern that provides a simplified interface to a complex subsystem, making it easier to use.

A creational pattern that provides an interface for creating objects in a superclass but allows subclasses to alter the type of objects that will be created.

A structural pattern that uses sharing to support large numbers of fine-grained objects efficiently.

A behavioral pattern that defines a representation for a grammar and provides an interpreter to deal with the grammar.

A behavioral pattern that provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

A behavioral pattern that defines an object that encapsulates how a set of objects interact, promoting loose coupling.

A behavioral pattern that allows capturing and externalizing an object’s internal state without violating encapsulation so that the object can be restored to this state later.

A behavioral pattern that uses a special null object instead of using null references to avoid null checks in the code.

A behavioral pattern where an object, known as the subject, maintains a list of its observers and notifies them of any state changes.

A creational pattern that enables cloning of existing objects without making the code dependent on their classes.

A structural pattern that provides an object representing another object. A proxy can control access to the subject, allowing for additional functionalities.

A creational design pattern that ensures a class has only one instance and provides a global point of access to it.