Software Design Patterns

In object-oriented programming, the singleton pattern is a software design pattern that restricts the instantiation of a class to a singular instance.

In object-oriented programming, the factory method pattern is a design pattern that uses factory methods to deal with the problem of creating objects without having to specify their exact classes.

The abstract factory pattern in software engineering is a design pattern that provides a way to create families of related objects without imposing their concrete classes, by encapsulating a group of individual factories that have a common theme without specifying their concrete classes.

The builder pattern is a design pattern that provides a flexible solution to various object creation problems in object-oriented programming.

The prototype pattern is a creational design pattern in software development.

In software engineering, the adapter pattern is a software design pattern (also known as wrapper, an alternative naming shared with the decorator pattern) that allows the interface of an existing class to be used as another interface.

The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently", introduced by the Gang of Four.

In software engineering, the composite pattern is a partitioning design pattern.

In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object dynamically, without affecting the behavior of other instances of the same class.

The facade pattern (also spelled façade) is a software design pattern commonly used in object-oriented programming.

In computer programming, the flyweight software design pattern refers to an object that minimizes memory usage by sharing some of its data with other similar objects.

In computer programming, the proxy pattern is a software design pattern which is a class functioning as an interface to something else.

In object-oriented programming, the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time.

In computer programming, the interpreter pattern is a design pattern that specifies how to evaluate sentences in a language.

In object-oriented programming, the iterator pattern is a design pattern in which an iterator is used to traverse a container and access the container's elements.

In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact.

The memento pattern is a software design pattern in the field of object-oriented programming that allows reverting the state of an object.

In software design and software engineering, the observer pattern is a software design pattern in which an object, called the subject (also known as event source or event stream), maintains a list of its dependents, called observers (also known as event sinks), and automatically notifies them of any state changes, typically by calling one of their methods.

The state pattern is a behavioral software design pattern that allows an object to alter its behavior when its internal state changes.

In computer programming, the strategy pattern (also known as the policy pattern) is a behavioral software design pattern that enables selecting an algorithm at runtime.

In object-oriented programming, the template method is one of the behavioral design patterns identified by Gamma et al. in the book Design Patterns.

A visitor pattern is a software design pattern that separates the algorithm from the object structure.