Design pattern is a general reusable solution to a commonly occurring problem in software design.
It deals with mechanism how the objects should be created in a specific situation.
Popular creational patterns are
- Abstract factory pattern, which provides an interface for creating related or dependent objects without specifying the objects’ concrete classes.
- Builder pattern, which separates the construction of a complex object from its representation so that the same construction process can create different representations.
- Factory method pattern, which allows a class to defer instantiation to subclasses.
- Prototype pattern, which specifies the kind of object to create using a prototypical instance, and creates new objects by cloning this prototype.
- Singleton pattern, which ensures that a class only has one instance, and provides a global point of access to it.
Structural patterns makes the design easy by identifying a simple way to realize relations among entities/classes.
Popular structural patterns are
- Adapter pattern: ‘adapts’ one interface for a class into one that a client expects.
- Bridge pattern: decouple an abstraction from its implementation so that the two can vary independently .
- Composite pattern: a tree structure of objects where every object has the same interface.
- Decorator pattern: add additional functionality to a class at runtime where subclassing would result in an exponential rise of new classes.
- Facade pattern: create a simplified interface of an existing interface to ease usage for common tasks.
- Flyweight pattern: a large quantity of objects share a common properties object to save space.
- Marker pattern: an empty interface to associate metadata with a class.
- Pipes and filters: a chain of processes where the output of each process is the input of the next.
- Proxy pattern: a class functioning as an interface to another thing.
Behavioral design patterns deal with how objects will be carrying out communication with each other.
Popular behavioral patters are
- Blackboard design pattern: provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies.
- Chain of responsibility pattern: Command objects are handled or passed on to other objects by logic-containing processing objects.
- Command pattern: Command objects encapsulate an action and its parameters.
- Interpreter pattern: Implement a specialized computer language to rapidly solve a specific set of problems.
- Iterator pattern: Iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation.
- Mediator pattern: Provides a unified interface to a set of interfaces in a subsystem.
- Memento pattern: Provides the ability to restore an object to its previous state (rollback).
- Null object pattern: Designed to act as a default value of an object
- Observer pattern: a.k.a. Publish/Subscribe or Event Listener. Objects register to observe an event that may be raised by another object.
- Scheduled-task pattern: A task is scheduled to be performed at a particular interval or clock time (used in real-time computing).
- Single-serving visitor pattern: Optimise the implementation of a visitor that is allocated, used only once, and then deleted.
- Specification pattern: Recombinable business logic in a boolean fashion.
- State pattern: A clean way for an object to partially change its type at runtime.
- Strategy pattern: Algorithms can be selected on the fly, using composition.
- Template method pattern: Describes the program skeleton of a program; algorithms can be selected on the fly, using inheritance.
- Visitor pattern: A way to separate an algorithm from an object.