Jon Bock - Development Tech Blog

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.