Design Patterns

Front 1

Factory

Back 1

This pattern is used to create concrete class instances without specifying the exact class type.

The essence of the Factory Pattern is to "Define an interface for creating an object, but let the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses." Factory methods encapsulate the creation of objects. This can be useful if the creation process is very complex, for example if it depends on settings in configuration files or on user input.

Front 2

Abstract Factory

Back 2

his pattern is used to create concrete class instances without specifying the exact class type. The Abstract Factory Pattern provides a way to encapsulate a group of individual factories that have a common theme.

Front 3

Flyweight

Back 3

A pattern used to maximize the sharing of objects resulting in reduced memory consumption.

Front 4

Singleton

Back 4

This pattern insures that only a single instance of a given object can exist.

Front 5

Builder

Back 5

The builder pattern describe a way to separate an object from it's construction.
The same construction method can create different representation of the object.
Use the pattern in the following situations:

* You need to construct a complex object which has different representation.

* The algorithm for creating the object should be independent of the way the object's parts is assembled.

Front 6

Adapter

Back 6

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

Front 7

Bridge

Back 7

Decouples an abstraction from its implementation so that the two can vary independantly.

Front 8

Composite

Back 8

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

Front 9

Decorator

Back 9

Allows an objects behavior to be altered at runtime.

This change in behavior is accomplished by wrapping an object with a new object. This new wrapper object is the Decorator. The Decorator object will implement the same interface as the object being wrapped. Because the decorated object uses the same interface as an undecorated object, other parts of your system do not need to be aware of whether or not one or more decorations are in use.

The decorator (wrapper) can now alter the behavior of the object being wrapped by either completely replacing various methods or by altering the behavior of the methods of the object being decorated.

Front 10

Facade

Back 10

Used to provide a simpler interface into a more complicated portion of code.

Front 11

Proxy

Back 11

Provides a Placeholder for another object to control access to it.

Front 12

Chain of Responsibility

Back 12

The chain of responsibility pattern is a way of communicating between objects.

As it’s name indicate a chain of handlers is built
and every handler in the chain is responsible to handle the passing request or deliver it to the next handler in the chain. In the end of the process the request is handled with a default or exceptional behavior.
The pattern helps to reduce coupling by freeing the object from knowing which handler will handle the request in the end.

Front 13

Command

Back 13

Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

Front 14

Iterator

Back 14

Provides a way to sequentially access aggregate objects without exposing the structure of the aggregate.

Front 15

Mediator

Back 15

The mediator pattern encapsulate the interaction between a set of objects.

Front 16

Memento

Back 16

Allows you to save the state of an object externally from that object.

Front 17

Observer

Back 17

Allows a single object to notify many dependent objects that its state has changed.

Front 18

State

Back 18

Allows an object to change its behaviour when its internal state changes.

Front 19

Strategy

Back 19

Allows multiple algorithms to be used interchangeably at runtime.

Front 20

Visitor

Back 20

The visitor design pattern enables us to create new operations to be performed on an existing structure.