Ensures a class has only one instance and provides a global point of access to that instance.

Defines an interface for creating an object but allows subclasses to alter the type of objects that will be created.

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 various representations.

Creates new objects by copying an existing object, known as the prototype.

Allows the interface of an existing class to be used as another interface.

Attaches additional responsibilities to an object dynamically.

Separates an objects abstraction from its implementation, allowing them to vary independently.

Composes objects into tree structures to represent part-whole hierarchies.

Provides a surrogate or placeholder for another object to control access to it.

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

Encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations.

Allows an object to alter its behavior when its internal state changes.

Passes a request along a chain of handlers. Upon receiving a request, each handler decides either to process it or to pass it to the next handler in the chain.

Represents an operation to be performed on the elements of an object structure. It lets you define a new operation without changing the classes of the elements on which it operates.

Provides a way to synchronize access to resources that are shared among multiple threads.

Controls access to a limited number of resources among multiple threads.

Deals with the efficient and safe sharing of data between producer and consumer threads.

Manages access to a resource that can be read by multiple threads simultaneously but written by only one thread at a time.

Separates an application into three interconnected components: Model, View, and Controller.

Similar to MVC, but with a focus on data binding and separation of concerns.

Provides an abstraction layer for data access, hiding the underlying data store and providing a consistent API for accessing data.