Design Patterns

1
Design Patterns

• Dependence management
• Creational patterns

2

• Composite
• Observer
• Template method
• Iterator
• Decorator

3
Decorators

• Decorators add an attribute to an object by
• making the object a component
• forwarding messages to component and handling
  others

4
Decorator Pattern
Element
specialized operations
Decorator
Primitive
Decorator forwards most operations to the object
it is decorating.
5
Document with Decorators
DocumentComponent

Composite
Paragraph
DocumentDecorator
Title, level
NumberDecorator Number
TitleDecorator Title
6
TitleDecorator
TitleDecorator
NumberDecorator
Composite
NumberDecorator
TitleDecorator
Paragraph
Composite
Paragraph
Composite
TitleDecorator
NumberDecorator
Composite
Paragraph
TitleDecorator
NumberDecorator
Composite
Paragraph
7
Dependence Management

• Bob Martin says Object-oriented programming is
  dependence management.
• See his Design Principles and Design Patterns
  at
• http//www.objectmentor.com/resources/articles/Pri
  nciples_and_Patterns.PDF

8
Dependence

• How can one package depend on another?
• Reuse a class
• By inheritance
• By instantiation (direct reference)
• Reuse a variable
• Reuse a method?

9
Dependence

• If package A depends on package B then you cant
  run the tests for A unless you also have B.
• A depends on B means you cant use A unless you
  have B.
• Package A depends on package B means that
  something in A depends on something in B.

10
Cycles of dependence

• If package A depends on package B then package B
  should NOT depend on package A.
• If classes C and D both depend on each other, put
  them in the same package.

11
Eliminating dependence

• The Observer pattern eliminates dependence.
• Suppose that FBIAgent is an observer of
  Mobster. Mobster is a subclass of Model, so it
  can have observers. Class FBIAgent probably
  depends on class Mobster, but Mobster does not
  depend on FBIAgent.

12
Observer Pattern
observer/ dependent
Subject addDependent removeDependent changed
Observer update

model
Mobster robBank driveCar
FBIAgent update
13
Application GUI
SUnit tests
GUI library
Application
Smalltalk base library
14
Abstract Server

• Bob Martins name for depend on an interface,
  not on a concrete class.

ltltinterfacegtgt Resource Manager
Consumer
Creation script
Client
Server
Interface
ResrcMgr1
15
Adapter

• Intent Convert the interface of a class into
  another interface clients expect. Adapter lets
  classes work together that couldnt otherwise
  because of incompatible interfaces.

Adaptee
Adapter
Target
16
Adapter
Target
Client
Adaptee
Request()
Adapter Request()
17
Adapter

• Allows client and adaptee to be unchanged
• Adapter is usually ugly

Adapter
Client
Adaptee
18
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. Example Insurance
policies must be approved before they are issued.
There is a procedure (which can change over
time, and which is different for different kinds
of policies) for approving a policy. This
procedure must interact with work queues of
managers and with the history that is kept on the
customer. Instead of putting this procedure in
the insurance policy, put it in a separate object
that is easy to change. (This is a
business process)
19
Not Mediator
InsurancePolicy
Worker
CustomerHistory
20
Mediator
InsurancePolicy
Mediator
Colleagues
Procedure
Worker
CustomerHistory
If interaction is main thing that changes, then
make the interaction be an object. Colleague
classes become more reusable. Mediator is the
non-reusable part.
21
Mediator
Business Rule
Mediator
Procedure
CustomerHistory
InsurancePolicy
Worker
Domain Objects
Colleagues
22
Application Model

• Mediator between widgets and domain model.

PayrollSystemInterface
ListView
TextView
Employee
PayrollSystem
23
Façade

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

Facade
24
The Compiler
Scanner
CompiledMethod
Compiler compile evaluate
Parser
SmalltalkExpression
Return Expression
AssignmentExpression
Message Expression
...
25
Creational Patterns

• Factory Method
• Factory Object
• Abstract Factory
• Builder
• Prototype
• Singleton

26
Factory Method

• Don't (call constructor / send message to class)
  directly.
• Make a separate function / method to create
  object.
• How to do it
• Find every class name in producer
• Extract it (or perhaps CN new) into a method

27
Factory Method

• Results
• Localizes dependencies
• Modules become less coupled
• Reduces coupling
• Can lead to parallel class hierarchies

28
Factory Method
Producer doSomething
doSomething self createXX ...
ConcreteProducer createXX
createXX XX new
XX
29
Factory Object

• Problem with factory method -- have to create
  subclass to parameterize.
• Often end up with parallel class hierarchies.
• Example subclass of Tool for each figure you
  want to create
• Alternative parameterize CreationTool with
  object that creates figure
• Smalltalk automatically creates a factory for
  every class, the Class!
• (Note Factory Object is generalization of
  Abstract Factory,Builder, and Prototype. It is
  not in the book.)

30
Applicability

• Use factory objects
• when system creates them automatically
• when more than one class needs to have product
  specified
• when most subclasses only specialize to override
  factory method

31
Figure
LineFigure
RectangleFigure
ElipseFigure
FigureFactory new
LineFigureFactory
RectangleFigureFactory
ElipseFigureFactory
32
Prototype

• Making a class hierarchy of factories seems
  wasteful.
• The parameters of an object can be as important
  as its class.
• Solution
• Use any object as a factory by copying it to make
  a new instance.
• Advantages
• Don't need new factory hierarchy.
• Can make new "class" by parameterizing an object
• Disadvantages
• Requires robust copying

33
Making Prototype

• You have a design in which objects are
  parameterized by passing in classes. You are
  making new classes just for their constructors,
  or you want to make composite classes.
• Make sure copy works. Define new as an
  instance method that returns a copy. Change
  client to pass in instances instead of classes.

34
Abstract Factory

• Sometimes a group of products are related -- if
  you change one, you might need to change them
  all.
• Solution
• Make a single object that can make any of the
  products.

WidgitFactory CreateScrollBar CreateWindow
ScrollBar
MotifScrollBar
PMScrollBar
MotifWidgetFactory CreateScrollBar CreateWindow
PMWidgetFactory CreateScrollBar CreateWindow
35
Making Abstract Factory

• Give Producer a component called Factory
• Create class Factory
• Add instance variable factory to Producer
• Change constructor to have line factoryFactory
  new
• Move factory methods to Factory
• Copy factory method to Factory
• Change sends of createFoo to factory createFoo

36
Builder

• Complex objects require a lot of work to make.
• Solution
• Factory must keep track of partly built product.
• Client specifies product by performing series of
  operations on factory.

WindowBuilder AddScrollBar AddButton GetWindow
Client
37
Implementing Builder

• Builder can make components using
• Factory Method
• Abstract Factory, or
• Prototype

WidgitFactory CreateScrollBar CreateWindow
WindowBuilder AddScrollBar AddButton GetWindow
MotifWidgetFactory CreateScrollBar CreateWindow
PMWidgetFactory CreateScrollBar CreateWindow
38
Making Builder

• There are several places in your system where a
  complex object is built. These places need to
  mention a lot of classes, unless you use a
  pattern like Abstract Factory.
• Constructors get complicated. Perhaps there are
  a lot of class methods that deal with
  construction. Construction needs temporary
  variables.
• Make a class that builds the object for you. It
  hides the concrete classes that are used and
  temporary variables used during construction.
• Result Producers not coupled with Product.
  Builder is coupled with Product.

39
Summary of Factory Patterns

• Factory method -- use in simple cases so that you
  can change product
• Abstract factory -- use when there is a set of
  related products
• Builder -- use when product is complex
• Prototype -- use when Factory Method is awkward
  and when classes are not objects, or when you
  want to specify new "classes" by composition

40
Singleton

• What if you want to make sure that a class has
  only one instance?
• One possibility is global variables. Another is
  using class methods.
• Best solution store single instance in class
  variable.

41
Singleton

• The singleton class has a class variable
  Instance and a class method
• instance
• Instance isNil ifTrue Instance super new.
• Instance
• Alternative make Instance a class instance
  variable.

42
Managing dependences

• Cost of eliminating dependences
• More abstract
• Harder to test
• Harder to understand
• It is OK to depend on stable packages.
• Stable doesnt change has many dependents

43
Managing dependences
Application
Subsystem2
Library1
Subsystem1
Library3
Library2
44
Managing dependences
Application1
Application2
Subsystem1
Suppose Application2 depends on only a small part
of Subsystem1, and that part doesnt depend on
Subsystem2
Subsystem2
45
Managing dependences
Application1
Application2
Subsystem1
Subsystem3
Subsystem2
46
Dependence management

• Determines
• Build times
• Difficulty of testing
• Frequency of rebuilding and retesting
• Ease of reuse
• Design patterns help control dependences

47
Design patterns and refactoring

• Patterns are most useful for complex systems.
• Add them later by refactoring
• Keep system simple no unnecessary patterns
• Keep system flexible all needed patterns

48
Summary

• Composite, Observer, Template method, Iterator,
  Decorator
• Adapter, Mediator, Façade
• Factory Method, Abstract Factory, Builder,
  Prototype, Singleton
• Next time Command, State, Visitor