Here is a quick summary of design patterns that everyone should know:-
- Builder - Separate the creation of a complex object from its representation so that we can use the same construction process to create different representations.
- Abstract factory - Using a interface to create families of related or dependent objects without specifying their concrete classes.
- Factory method - Define a interface for creating an object but let their subclasses decide how they are implemented.
- Prototype - Design a prototype instance and use it to create new objects by copying this prototype.
- Singleton - Create only one instance of a object and ensure that it is globally accessible.
Structural design patterns
- Adapter - Create a interface that lets you interact with another interface the client expects, it lets incompatible classes work together.
- Builder - Decouple the abstraction from its implementation so the two can vary independently.
- Composite - Compose objects into tree structures to enable recursive composition.
- Decorator - Add additional responsibilities to an object dynamically.
- Facade - Provide a unified interface to a set of interfaces in a subsystem. Makes it easier to use subsystems by using this higher level interface.
- Flyweight - Support the sharing of large number of fine grained objects efficiently.
- Proxy - Provide a placeholder for another object to control access to it.
Behavioral design patterns
- Chain of responsibility - Avoid coupling the sender from the receiver by allowing other objects a chance to handle it.
- Command - Encapsulate a request as a object and let you parametrize with different request, queues or logs. Supports undoable operations.
- Interpreter - Given a langauge, define a representation for its grammar along with interpreter that uses the representation to interpret sentences in the language.
- Iterator - Provide ways to access items in a object in a sequential manner without exposing its underlying representation.
- Mediator - Promotes loose coupling between objects and prevents them from referring to each other directly, encapsulates how a set of objects interact.
- Memento - Without violating encapsulation, capture and externalize and objects internal state so that it can later be returned to this state later.
- Observer - Define a one to many relationship between objects so then when one objects state changes all its dependencies are notified and updated.
- State - Allow an object to be able to change its behaviour when its internal state changes so that it appears that the objects class has changed.
- Strategy - Define a family of algorithms, encapsulate each one and make them interchangeable. Allows you to vary the algorithm independently from the clients that use it.
- Template method - Define a skeleton of algorithm in a operation whilst deferring some steps to client subclasses. Allows you to redefine steps in the algorithm without changing the algorithms structure.
- Visitor - Represent an operation to be performed on elements of a object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.