Design Patterns

CSc 335
Object-Oriented Programming and Design
Fall 2006
Acknowledgements
• These slides were written by Richard Snodgrass. Some slides from
Rick Mercer and Martin Stepp were used.

• They include information in Design Patterns: Elements of

Reusable Object-Oriented Software, by Erich Gamma, Richard
Helm, Ralph Johnson, and John Vlissides, Addison-Wesley
Publishing Company, 1995.

• Some information was taken from Refactoring: Improving the

Design of Existing Code, by Martin Fowler, Addison-Wesley
Publishing Company, 1999.

• Inspiration was also taken from Head First Design Patterns, by

 Eric Freeman, Elisabeth Freeman, Kathy Sierra, and Bert Bates,
O’Reilly Media, October, 2004.
P-2
Patterns I
Outline

• Overview of Patterns

• Iterator

• Strategy

P-3
Patterns I
The Germ of this Approach
• Christopher Alexander, architect
 A Pattern Language---Towns, Buildings, Construction
(1977)
 Timeless Way of Building (1979)
 “Each pattern describes a problem which occurs over and
over again in our environment, and then describes the core of
the solution to that problem, in such a way that you can use
this solution a million times over, without ever doing it the
same way twice.”

• Other patterns: novels (tragic, romantic, crime),

movies, bureaucratic memos, political speeches…

P-4
Patterns I
“Gang of Four” (GoF) Book
• Design Patterns: Elements of Reusable Object-
Oriented Software, Addison-Wesley Publishing
Company, 1994.
 Dr. Erich Gamma, then Software Engineer, Taligent, Inc.;
now at Object Technology International as the technical
director of the Zurich lab in Switzerland.
 Dr. Richard Helm, then Senior Technology Consultant, DMR
Group; now at the Boston Consulting Group.
 Dr. Ralph Johnson, then and now at University of Illinois,
Computer Science Department; now a Research Associate
Professor.
 Dr. John Vlissides, then a researcher at IBM Thomas J.
Watson Research Center.
P-5
Patterns I
Patterns
• This book defined 23 patterns, classified into three
categories.
 Creational patterns, which deal with the process of object
creation.
 Structural patterns, which deal primarily with the static
composition and structure of classes and objects.
 Behavioral patterns, which deal primarily with dynamic
interaction among classes and objects.
• Many other patterns have been introduced by others.
 For example, the book Data Access Patterns by Clifton
Nock introduces 4 decoupling patterns, 5 resource patterns, 5
I/O patterns, 7 cache patterns, and 4 concurrency patterns.
 Hundreds of patterns have been documented since; other
examples include telecommunications patterns, pedagogical
patterns, analysis patterns, and indexing patterns.
P-6
Patterns I
GoF Patterns
• Creational Patterns • Behavioral Patterns
 Abstract Factory  Chain of Responsibility
 Builder  Command
 Factory Method  Interpreter
 Prototype  Iterator
 Singleton  Mediator
• Structural Patterns  Memento
 Adapter  Observer
 Bridge  State
 Composite  Strategy
 Decorator  Template Method
 Façade  Visitor
 Flyweight
 Proxy

P-7
Patterns I
 Why Study Patterns?
• Can reuse solutions.
 Gives us a head start
 Avoids the gotchas later (unanticipated things)
 No need to reinvent the wheel

• Establish common terminology

 Design patterns provide a common point of reference
 Easier to say, “We need some Strategies here.”

• Provide a higher level prospective.

 Frees us from dealing with the details too early.
P-8
Patterns I
A Common Style for Patterns

• Formats of pattern writers vary, but a pattern

description usually has at least these four things.
 A name
 The purpose of the pattern, the problem it solves
 A guide for how to accomplish the solution
 The constraints and forces to be considered in order to
accomplish the solution

P-9
Patterns I
Style for Describing Patterns
• We will use this structure in these slides.
• Pattern name
• Recurring problem: what problem the pattern addresses
• Solution: the general approach of the pattern
• Also known as: other names for the pattern
• UML for the pattern
• Participants: a description of the classes in the UML
• Explanation
• Use Example(s): examples of this pattern, in Java
• Variant(s): different refinements of this pattern

P-10
Patterns I
Outline
• Overview of Patterns

• Iterator

• Strategy

P-11
Patterns I
Iterator Pattern
• Recurring Problem:
 You have an aggregate data type. How can you access the
elements sequentially without exposing its underlying
representation?

• Solution:
 Provide a separate object, an iterator, that can retain the
current position, and go to the next element.

• Also known as:

 Cursor

P-12
Patterns I
Use Example: Collections Framework
• The Collections framework has an Iterator
interface.
 boolean hasNext() Is the iterator positioned at the last
element in the aggregate?
 Object next() Move to the next element and return it.
 void remove() Remove the object most recently
returned by next().
• The remove() method is optional. If an Iterator
does not support this method, it throws
java.lang.UnsupportedOperationException
when invoked.
• Collection has the method
Iterator Iterator()
P-13
Patterns I
Use Example, cont.
• An Iterator can be used to look through the elements of any
kind of collection (as an alternative to a for loop).

Song song1 = new Song("Cheryl Crowe", "Home", 124, "Home.mid");

Song song2 = new Song("Sting", "Fields of Gold", 212, "gold.mp3");
Song song3 = new Song("Beatles", "Help", 132, "Help.mid");

Collection<Song> allSongs = new TreeSet<Song>();

allSongs.add(song1); TreeSet could be ArrayList, LinkedList
allSongs.add(song2);
allSongs.add(song3);

// Iterate over all elements

Iterator<Song> itr = allSongs.iterator();
while (itr.hasNext()) {
Song s = itr.next();
System.out.println(s.getArtist());
}

P-14
Patterns I
Strategy Pattern
• Recurring Problem:
 We want to be able to switch strategies

• Solution:
 Define a strategy as an interface, then instantiate multiple
strategies as concrete classes

• Also known as:

 Policy

P-15
Patterns I
Participants
• Context
 Maintains a reference to a Strategy object.
 Example: The content pane of a JFrame has a layout strategy that can be
changed

• Strategy
 Declares an interface common to all supported algorithms:
AlgorithmInterface.
 Example interface LayoutManager that defines methods that to place
components

• ConcreteStrategy
 Implements the Algorithm interface.
 Example: BorderLayout, GridLayout, FlowLayout, ...

P-16
Patterns I
Layout Managers
• There are five predefined layout managers in the
javax.swing package:

flow layout

border layout

card layout

grid layout

grid bag layout
• Each container has a default layout manager
• You can also create you own custom layout managers
but not necessary here

P-17
Patterns I
A Layout Manager

• By default, JFrame uses BorderLayout

getContentPane().setLayout(new FlowLayout());

• Then when you add, things are added laid out

according to the layout strategy

P-18
Patterns I
Flow Layout
• Components are placed in a row from left to right
in the order in which they are added
• A new row is started when no more components
can fit in the current row
• Components are centered in each row

P-19
Patterns I
Example of FlowLayout in a JFrame
import java.awt.Container;
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;

public class FrameWithFlowLayout extends JFrame {

public static void main(String[] args) {
new FrameWithFlowLayout().setVisible(true);
}

public FrameWithFlowLayout() {
setSize(200, 160);
Container contentPane = this.getContentPane();
// Without changing layout manager, all buttons go to Center
contentPane.setLayout(new FlowLayout());
contentPane.add(new JButton("1"));
contentPane.add(new JButton("2"));
contentPane.add(new JButton("3"));
contentPane.add(new JButton("4"));
contentPane.add(new JButton("5"));
contentPane.add(new JButton("6"));
contentPane.add(new JButton("7"));
contentPane.add(new JButton("8"));
contentPane.add(new JButton("9"));
}
}

P-20
Patterns I
Grid Layout
• Components are placed in a grid with a user-specified
number of columns and rows
• Each component occupies exactly one grid cell
• Grid cells are filled left to right and top to bottom
• All cells in the grid are the same size
• Change the strategy like this to see the different
arrangement
contentPane.setLayout(new GridLayout(3, 3));

P-21
Patterns I