Design Patterns

Front 1

Adapter

Back 1

new interface

wrap a legacy object that provides an incompatible interface with an object that supports the desired interface

Front 2

Facade

Back 2

simplified interface

wrap a complicated subsystem with an object that provides a simple interface

Front 3

proxy

Back 3

same interface

wrap an object with a surrogate object that provides additional functionality

Front 4

strategy

Back 4

standard polymorphism

define algorithm interface in a base class and implementations in derived classes

Front 5

factory method

Back 5

polymorphism for creation

define "createInstance" placeholder in the base class, each derived class calls the "new" operator and returns an instance of itself

Front 6

visitor

Back 6

double polymorphism

define "accept" method in first inheritance hierarchy, define "visit" methods in second hierarchy ... a.k.a. "double dispatch"

Front 7

builder

Back 7

the "reader" delegates to its configured "builder" ... each builder corresponds to a different representation or target

Front 8

state

Back 8

finite state machine

the FiniteStateMachine delegates to the "current" state object, and that state object can set the "next" state object

Front 9

bridge

Back 9

the wrapper models "abstraction" and the wrappee models many possible "implementations" ... the wrapper can use inheritance to support abstraction specialization

Front 10

observer

Back 10

the "model" broadcasts to many possible "views", and each "view" can dialog with the "model"

Front 11

composite

Back 11

derived Composites contain one or more base Components, each of which could be a derived Composite

Front 12

decorator

Back 12

a Decorator contains a single base Component, which could be a derived ConcreteComponent or another derived Decorator

Front 13

chain of responsibility

Back 13

define "linked list" functionality in the base class and implement "domain" functionality in derived classes

Front 14

interpreter

Back 14

map a domain to a language, the language to a recursive grammar, and the grammar to the Composite pattern

Front 15

command

Back 15

callback

encapsulate an object, the method to be invoked, and the parameters to be passed behind the method signature "execute"

Front 16

iterator

Back 16

traversal of a collection

encapsulate the traversal of collection classes behind the interface "first..next..isDone"

Front 17

mediator

Back 17

many-to-may relationships

decouple peer objects by encapsulating their "many to many" linkages in an intermediary object

Front 18

memento

Back 18

undo

encapsulate the state of an existing object in a new object to implement a "restore" capability

Front 19

prototype

Back 19

the new operator

encapsulate use of the "new" operator behind the method signature "clone" ... clients will delegate to a Prototype object when new instances are required

Front 20

abstract factory

Back 20

each platform creates products

model "platform" (e.g. windowing system, operating system, database) with an inheritance hierarchy, and model each "product" (e.g. widgets, services, data structures) with its own hierarchy ... platform derived classes create and return instances of product derived classes

Front 21

template method

Back 21

define skeleton, defer implementation

define the "outline" of an algorithm in a base class ... common implementation is staged in the base class, peculiar implementation is represented by "place holders" in the base class and then implemented in derived classes

Front 22

flyweight

Back 22

when dozens of instances of a class are desired and performance boggs down, externalize object state that is peculiar for each instance, and require the client to pass that state when methods are invoked

Front 23

singleton

Back 23

engineer a class to encapsulate a single instance of itself, and "lock out" clients from creating their own instances