Design Patterns

What Is a Design Pattern?

• A design pattern
– Is a common solution to a recurring problem in design
– Abstracts a recurring design structure
– Names & specifies the design structure explicitly
– Distils design experience
• A design pattern has 4 basic parts:
– 1. Name
– 2. Problem
– 3. Solution
– 4. Consequences and trade-offs of application
• Language- and implementation-independent
• A “micro-architecture”
• GoF (“the gang of four”) catalogue: “Design Patterns: Elements of
Reusable Object-Oriented Software,” Gamma, Helm, Johnson,
Vlissides, Addison-Wesley, 1995
 List of Patterns (not the end..)
Creational patterns Structural patterns
1 Abstract factory 28 Adapter, Wrapper, or Translator
2 Builder 29 Bridge
3 Dependency Injection 30 Composite
4 Factory method 31 Decorator
5 Lazy initialization 32 Extension object
6 Multiton 33 Facade
7 Object pool 34 Flyweight
8 Prototype 35 Front controller
9 Resource acquisition is initialization (RAII) 36 Marker
10 Singleton 37 Module
38 Proxy
Concurrency patterns 39 Twin
11 Active Object
12 Balking Behavioral patterns
13 Binding properties 40 Blackboard
14 Blockchain 41 Chain of responsibility
15 Compute kernel 42 Command
16 Double-checked locking 43 Interpreter
17 Event-based asynchronous 44 Iterator
18 Guarded suspension 45 Mediator
19 Join 46 Memento
20 Lock 47 Null object
21 Messaging design pattern (MDP) 48 Observer or Publish/subscribe
22 Monitor object 49 Servant
23 Reactor 50 Specification
24 Read-write lock 51 State
25 Scheduler 52 Strategy
26 Thread pool 53 Template method
27 Thread-specific storage 54 Visitor
The Singleton Pattern

“One of a Kind Objects”

 What is this?
• Singleton: How to instantiate just one object - one and only one!
• Why?
– Many objects we need only one of: thread pools, caches, dialog boxes,
objects that handle preferences and registry settings etc.
– If more than one instantiated:
• Incorrect program behavior, overuse of resources, inconsistent results
• Alternatives:
– Use a global variable
• Downside: assign an object to a global variable then that object might be
created when application begins. If application never ends up using it and
object is resource intensive  waste!
– Use a static variable
• Downside: how do you prevent creation of more than one class object?
 The Little Singleton (contd.)
• Is there any class that could use a private constructor?
• What’s the meaning of the following?

public MyClass {
public static MyClass getInstance ( ) { }
}

• Instantiating a class with a private constructor:

public MyClass {
private MyClass ( ) { }
public static MyClass getInstance ( ) { }
}
 The Classic Singleton Pattern
public class Singleton {
Constructor is private static Singleton uniqueInstance;
declared private; // other useful instance variables
only singleton can
We have a static
instantiate this
private Singleton ( ) { } variable to hold
class!
our one instance
public static Singleton getInstance ( ) { of the class
if (uniqueInstance == null) { Singleton.
uniqueInstance = new Singleton ( );
}
The getInstance ( ) method
gives us a way to instantiate return uniqueInstance;
the class and also return an }
instance of it.

// other useful methods

} Of course, Singleton is a
regular class so it has other
useful instances and
methods.
 Code Up Close
uniqueInstance holds our ONE If uniqueInstance is null, then we
instance; remember it is a static haven’t created the instance yet…
variable

if (uniqueInstance == null) {
uniqueInstance = new Singleton ( );
}
return uniqueInstance;

If uniqueInstance wasn’t null, then it was

previously created. We just fall through …and if it doesn’t exist, we
to the return statement. In either case, instantiate Singleton
we have an instance and we return it. through its private
constructor and assign it to
the uniqueInstance. Note
that if we never need the
uniqueInstance, it never
gets created --> lazy
instantiation.
 Singleton Pattern Defined
The Singleton Pattern ensures a class has only one instance, and
provides a global point of access to it.

The getInstance ( ) method The uniqueInstance class

is static, which means it is a variable holds our one and
class method, so you can Singleton only one instance of
conveniently access this Singleton.
method anywhere in your static uniqueInstance
code using
// other useful variables
Singleton.getInstance ( ).
That’s just as easy as
accessing a global variable,
but we get benefits like lazy static getInstance ( )
instantiation from the
// other methods
Singleton.

A class implementing a Singleton Pattern is

more than a Singleton; it is a general purpose
class with its own set of data and methods.
 Singleton Summary
• The Singleton Pattern ensures you have at most one
instance of a class in your application
• The Singleton Pattern also provides a global access
point to that instance.
• Java’s implementation of the Singleton Pattern makes
use of a private constructor, a static method combined
with a static variable
The Façade Pattern

Simplify, simplify, simplify!

 Façade
• Pattern that wraps objects, to simplify the
interface
• Aptly named as this pattern hides all the
complexity of one or more classes behind a
clean, well-lit façade!
 Home Sweet Home Theater
That’s a lot of classes,
Building your own home theater - check out the a lot of interactions,
components that you have/need to put together. and a big set of
interfaces to learn
Amplifier
and use.
tuner
dvdPlayer
cdPlayer DvdPlayer
Tuner amplifier
on ()
amplifier on ()
off ( )
on () off ( )
setCD( )
off ( ) eject ( )
setDVD ( )
setAM ( ) pause ( )
setStereoSound ( )
setFM ( ) play ( )
setSurroundSound ( )
setFrequency ( ) setSurroundAudio ( )
setTuner ( )
setTwoChannelAudio ( )
setVolume ( )
stop ( )

Screen
up () TheaterLights
down ( ) on ( )
off ( ) Projector
CdPlayer dvdPlayer
dim ( )
amplifier on ()
on () off ( )
off ( ) tvMode ( )
PopcornPopper eject ( ) wideScreenMode ( )
on ( ) pause ( )
off ( ) play ( )
pop ( ) stop ( )
 Watching a Movie the Hard Way!
1. Turn on the popcorn popper
2. Start the popper popping
3. Dim the lights
4. Put the screen down
5. Turn the projector on But there’s more!
6. Set the projector input to DVD When the movie is done, how
7. Put the projector on wide-screen mode do you turn everything off? Do
you reverse all the steps?
8. Turn the sound amplifier on Wouldn’t it be just as complex
9. Set the amplifier to DVD input to listen to a CD or radio?
10. Set the amplifier to surround sound If you decide to upgrade your
system, you’re probably going
11. Set the amplifier volume to medium (5) to have to learn a slightly
12. Turn the DVD player on different procedure!
13. Start the DVD player playing.
Façade to the Rescue!!
14. Whew!
 Lights, Camera, Façade! HomeTheaterFacade
(1) Create a Façade for the (2) The Façade treats the home
HomeTheater which exposes a few watchMovie ()
endMovie () theater components as its subsystem,
simple methods such as watchMovie ( ) and calls on the subsystem to
listenToCD ( )
endCD () implement its watchMovie ( ) method.
listenToRadio ()
endRadio ( )
(4) The Façade still leaves
the subsystem accessible to
(3) The Client now Amplifier be used directly.
calls methods on the tuner
dvdPlayer
façade and not on DvdPlayer
cdPlayer
the subsystem. Tuner
on () amplifier
amplifier on ()
off ( )
on () off ( )
setCD( )
off ( ) eject ( )
setDVD ( )
setAM ( ) pause ( )
setStereoSound ( )
setFM ( ) play ( )
setSurroundSound ( )
setFrequency ( ) setSurroundAudio ( )
setTuner ( )
setVolume ( ) setTwoChannelAudio ( )
stop ( )

Screen
up () TheaterLights
down ( ) on ( )
The subsystem off ( ) Projector
CdPlayer dvdPlayer
the façade is dim ( )
amplifier on ()
simplifying. on () off ( )
off ( ) tvMode ( )
PopcornPopper eject ( ) wideScreenMode ( )
on ( ) pause ( )
off ( ) play ( )
pop ( ) stop ( )
 The Façade Defined
The Façade Pattern provides a unified interface to a set of interfaces in a subsytem.
Façade defines a higher-level interface that makes the subsystem easier to use.
Unified interface
Happy client that is easier to use.
whose job just Client Facade
became easier
because of the
façade.

More complex subsystem

 Design Principle
• Principle of Least Knowledge - talk only to your immediate
friends!

• What does it mean?

– When designing a system, for any object, be careful of the number of
classes it interacts with and also how it comes to interact with those
classes.
• This principle prevents us from creating designs that have a large
number of classes coupled together so that changes in one part of
the system cascade to the other parts.
– When you build a lot of dependencies between many classes, you are
building a fragile system that will be costly to maintain and complex for
others to understand!
 The Adapter Pattern

Putting a Square Peg in a Round

Hole!
 Adapters
• Real world is full of them!
– Some examples?
• Object oriented adapters
– Scenario: you have an existing software system that you need to work a
new vendor library into, but the new vendor designed their interfaces
differently than the last vendor.

Your Existing Vendor Their interface doesn’t match the one you’ve
System Class written your code against. Not going to work!

The adapter
– What to do? Write a class that adapts the new vendor interface into the one
implements And talks to the vendor interface to service
the
interface
you’re expecting. your requests
your classes
Your Existing Vendor Your Existing Adapter Vendor
expect
System
Adapter
Class == System Class

No code changes
No code changes New code
 If it walks like a duck…..
• If it walks like a duck and quacks like a duck, then it
might be a duck turkey wrapped with a duck adapter….
public interface Duck { Meet the fowl!
public void quack ();
public void fly (); public interface Turkey {
} public void gobble ();
public class MallardDuck implements Duck { public void fly ( );
public void quack () { }
System.out.println(“Quack”);
} public class WildTurkey implements Turkey {
public void fly ( ) { public void gobble ( ) {
System.out.println(“Gobble Gobble”);
System.out.println (“I am flying”);
}
}
public void fly ( ){
} System.out.println(“I’m flying a short distance”);
}
}

Concrete implementations are similar -- just print out the actions.

 Now….
• Lets say you are short on Duck objects and would like to use
some Turkey objects in their place.
– Can’t use them outright because they have a different interface.
First, you need to implement the interface of
public class TurkeyAdapter implements Duck { the type you are adapting to. This is the
Turkey turkey; interface your client expects.
public TurkeyAdapter (Turkey turkey) {
this.turkey = turkey;
}
public void quack ( ) { Next, we need to get a reference to the object that we
turkey.gobble ( ); are adapting; here we do that through the constructor.
}
public void fly ( ){
for (int j = 0; j<5; j++) Now we need to implement all the methods in the
turkey.fly ( ); interface; the quack() translation between classes is easy;
} just call the gobble method.
}
}
Even though both interfaces have a fly ( ) method, Turkeys fly in
short spurts -- they can’t do long distance flying like ducks. To map
between a Duck’s fly ( ) method and a Turkey’s we need to call the
Turkey’s fly ( ) method five times to make up for it.
 The Adapter Pattern Defined
The Adapter Pattern converts the interface of a class into another
interface the clients expect. Adapter lets classes work together that
couldn’t otherwise because of incompatible interfaces.

Client <<Interface>>
Target The Adapter implements the target
request ( ) interface
The client sees only the
Target interface.

Full
Full of
of good
good OO
OO design
design principles:
principles:
--Use
--Use ofof object
object composition
composition
--Pattern
--Pattern binds
binds the
the client
client to
to an
an Adapter Adaptee
interface and not an implementation
interface and not an implementation request ( ) specificRequest ()

Adapter is composed with

All requests get delegated to the Adaptee
the Adaptee
 Adapter Summary
• Pattern that wraps objects to change its interface
• When you need to use an existing class and its interface is not the
one you need, use an adapter.
• An adapter changes an interface into one a client expects.
• Implementing an adapter may require little work or a great deal
of work depending on the size and complexity of the target
interface.
• An adapter wraps an object to change its interface, a decorator
(another pattern) wraps an object to add new behaviors and
responsibilities.
 Observer Pattern

Keeping your Objects in the Know!

 The Weather-O-Rama!
Current conditions is
one of three different
displays. The user can
also get weather stats
and a forecast.

Pulls data Displays

Humidity Sensor Current
Device Conditions

Temp: 72
Humidity: 60
Temperature Sensor Pressure:
Device

Weather Station

Display Device

Pressure Sensor
Device

Weather-O-Rama provides What we implement

The Job: Create an app that uses the WeatherData object to update
three displays for current conditions, weather stats, and a forecast.
 Time for the Observer!
• The Newspaper or Magazine subscription model:
– A newspaper publisher goes into business and begins
publishing newspapers
– You subscribe to a particular newspaper, and every time there
is a new edition, its gets delivered to you. As long as you
remain a subscriber, you get new newspapers.
– You unsubscribe when you don’t want the newspapers
anymore -- and they stop being delivered
– While the publisher remains in business people, hotels,
airlines etc constantly subscribe and unsubscribe to the
newspaper.
 Publishers + Subscribers = Observer Pattern
The observers have subscribed to the
Subject to receive updates when the
• Publisher == Subject subject’s data changes.
• Subscribers == Observers

Subject object New data values are communicated to the

manages some data. observers in some form when they change.

2 2

This object isn’t an int 2

observer so it doesn’t get
notified when the
subject’s data changes.
When data in the Subject
changes, the observers are
notified. Observer Objects
 The Observer Pattern Defined
The Observer Pattern defines a one-to-many dependency between
objects so that when one object changes state, all of its dependents are
notified and updated automatically.
One to many relationship (Subject can have many observers)
Object that holds state

2 2

int 2
Dependent objects
(observers are
dependent on the
subject to update
Observer Objects them when data
Automatic update/notification changes.)
 Observer Class Diagram
Here’s the Subject interface. Objects use All potential observers need to
this interface to register as observers and implement the Observer
also to remove themselves from being Each subject can have
many observers interface. This interface has just
observers. one method, update ( ), that gets
called when the Subject’s state
changes.

The concrete subject may also have

methods for setting and getting its state.

A concrete subject always implements the Subject interface. In addition Concrete observers can be any class that
to the register (attach) and remove (detach) methods, the concrete implements the Observer interface. Each
subject implements a notify() method to notify observers whenever state observer registers with a concrete subject to
changes. receive updates.
 Designing the Weather Station Create an interface for all display
All weather components implement the Observer elements to implement. The display
Subject interface interface. This gives the subject a common elements just need to implement a
interface to talk to when it comes time to update. display ( ) method.

<<interface>> <<interface>> <<interface>>

Subject observers Observer DisplayElement
display ( )
registerObservers ( ) update ( )
removeObservers ( )
notifyObservers ( )

CurrentConditions ForecastDisplay

update ( ) update ( )
WeatherData display ( ) { // display display ( ) { // display
current measurements } the forecast }
registerObservers ( )
removeObservers ( )
notifyObservers ( )
StatisticsDisplay
getTemperature ( )
getHumidity ( ) update ( )
getPressure ( ) display ( ) { // display
measurementsChanged ( ) avg, min, and max
measurements }
WeatherData now
implements the Subject
interface.
 Implementing the Weather Station
public interface Subject {
public void registerObserver (Observer o); Both of these methods take an Observer
public void removeObserver (Observer o); as an argument, that is the Observer to
be registered or removed.
public void notifyObservers ( );
}
This method is called to notify all
observers when the Subject’s state has
public interface Observer { changed.
public void update (float temp, float humidity, float pressure); The Observer interface is
} implemented by all observers,
so they all have to implement
the update ( ) method.
public interface DisplayElement {
public void display ( );
} These are the state values
the Observers get from the
Subject when a weather
measurement changes.

The DisplayElement interface

just includes one method,
display ( ), that we will call
when the display element
needs to be displayed.
 Implementing the Subject Interface
in WeatherData
public class WeatherData implements Subject {
private ArrayList observers;
private float temperature;
private float humidity;
private float pressure;
Added an ArrayList to hold the Observers,
public WeatherData ( ){ and we create it in the constructor
observers = new ArrayList ( );
}
public void registerObserver (Observer o) {
observers.add(o);
}
public void removeObserver (Observer o) {
int j = observer.indexOf(o);
if (j >= 0) {
observers.remove(j);
Here we implement the Subject Interface
}}
public void notifyObservers ( ) {
for (int j = 0; j < observers.size(); j++) {
Observer observer = (Observer)observers.get(j);
observer.update(temperature, humidity, pressure);
}} Notify the observers when measurements change.
public void measurementsChanged ( ) {
notifyObservers ( ); }
// add a set method for testing + other methods.
}
 Observer Summary
• OO Principle in play: Strive for loosely coupled designs between objects that
interact.
• Main points:
– The Observer pattern defines a one to many relationship between objects
– Subjects (observables), update Observers using a common interface
– Observers are loosely coupled in that the Observable knows nothing about them,
other than they implement the Observer interface.
– You can push or pull data from the Observable when using the pattern (“pull” is
considered more correct)
– Don’t depend on a specific order of notification for your Observers
– Java has several implementations of the Observer Pattern including the general
purpose java.util.Observable
– Watch out for issues with java.util.Observable
– Don’t be afraid to create our own version of the Observable if needed
– Swing makes heavy use of the Observer pattern, as do many GUI frameworks
– You find this pattern in other places as well including JavaBeans and RMI.