Design patterns in one page

Main Opps concepts are classes, object ,  inheritance , polymorphism , abstraction  and  encapsulation .
Classes can have fixed state and fixed behavior  while object can have dynamic state and behavior .

You can use either object composition or class inheritance (class inheritance or interface inheritance ) while designing classes .Inheritance is tied to class at compile time .So such behavior is static at run-time . This is the main theme used class scoped  design patterns .


You can create large number of granular objects and use dynamic composition through polymorphism  to change behavior  at run-time as per your need. This is major theme used in object scoped  design patterns .

While designing always program  to interface and not to implementation so that code is reusable to client  and owner could plug-in any implementation as per need which client is unaware of . This is also major theme in most of design patterns .

Main Concepts :

Inheritance  (Extending abstract class , implementing one or many interfaces / abstraction/generalization/realization/Is_A  )

Inheritance is fixed at compile time so it has static behavior .

Composition (Association/Aggregation/composition / Has_A )
Composition can be decided at run time so it has  dynamic behavior  .


Creation Patterns 

Abstract Factory (Kit)
Provide an interface for creating families of related or dependent objects without specifying their
concrete classes.

Builder
Separate the construction of a complex object from its representation so that the same construction
process can create different representations.

Factory Method
Define an interface for creating an object, but let sub-classes decide which class to instantiate. Factory
Method lets a class defer instantiation to sub-classes.

Prototype
Specify the kinds of objects to create using a prototypical instance, and create new objects by
copying this prototype.

Singleton
Ensure a class only has one instance, and provide a global point of access to it.


Structural Patterns 

Adapter
Convert the interface of a class into another interface clients expect. Adapter lets classes work
together that couldn't otherwise because of incompatible interfaces.

Bridge
Decouple an abstraction from its implementation so that the two can vary independently.

Composite
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat
individual objects and compositions of objects uniformly.

Decorator
Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative
to sub-classing for extending functionality.

Facade
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level
interface that makes the subsystem easier to use.

Flyweight
Use sharing to support large numbers of fine-grained objects efficiently.

Proxy
Provide a surrogate or placeholder for another object to control access to it.


Behavior Pattern 

Chain of responsibility
Avoid coupling the sender of a request to its receiver by giving more than one object a chance to
handle the request. Chain the receiving objects and pass the request along the chain until an object
handles it.

Command
Encapsulate a request as an object, thereby letting you parameterize clients with different requests,
queue or log requests, and support undo-able operations.

Interpreter
Given a language, define a representation for its grammar along with an interpreter that uses the
representation to interpret sentences in the language.

Iterator
Provide a way to access the elements of an aggregate object sequentially without exposing its
underlying representation.

Mediator
Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by
keeping objects from referring to each other explicitly, and it lets you vary their interaction

independently.

Memento
Without violating encapsulation, capture and externalize an object's internal state so that the object
can be restored to this state later.

Observer
Define a one-to-many dependency between objects so that when one object changes state, all its

dependents are notified and updated automatically.

State
Allow an object to alter its behavior when its internal state changes. The object will appear to change
its class.

Strategy
Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets
the algorithm vary independently from clients that use it.

Template Method
Define the skeleton of an algorithm in an operation, deferring some steps to sub-classes. Template
Method lets sub-classes redefine certain steps of an algorithm without changing the algorithm's
structure.

Visitor
Represent an operation to be performed on the elements of an object structure. Visitor lets you define
a new operation without changing the classes of the elements on which it operates.


Non GOF patterns 

Object Pool
MVC pattern
Dependency Injection


Practical Hybrid Patterns :

Factory Method + Prototype +Singleton

If you have to create very large number of types of objects using factory method then you need to pass some type identifier are parameter to factory method , then in factory method you have to create large number of if-else clauses or long switch clauses to implement logic .
To void this you can keep map or registry of type identifier  to object . The sub-classes should be clone-able or have copy constructor or they are singleton . So when request  comes to factory method with type identifier , look up in registry get  object of the type then either return clone of object or singleton object .
Instead of keeping registry  of objects you can keep mapping of type identifier to class then using reflection you can create objects on fly and return for the specified types .
Registry could be map /server or simply property /JON /XML file .