Programming Design Patterns Summary

Here is a quick summary of design patterns that everyone should know:-

Factory Patterns

  • 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.