Software Architecture

and Design
Design Patterns and GUI Programming

Reading:
Object-Oriented Design and Patterns, Ch. 5 (Horstmann)

1
 Big questions
 What is a design pattern?

 What is the advantage of knowing/using

design patterns?

 Which patterns are named in the reading?

What are the key ideas of those patterns?

2
 Design challenges
 Designing software for reuse is hard. One must find:
 a good problem decomposition, and the right software
 a design with flexibility, modularity and elegance
 designs often emerge from trial and error
 successful designs do exist
 two designs they are almost never identical
 they exhibit some recurring characteristics
 Can designs be described, codified or standardized?
 this would short circuit the trial and error phase
 produce "better" software faster

3
 Design patterns
 design pattern:
a solution to a common software problem in a context
 describes a recurring software structure
 is abstract from programming language
 identifies classes and their roles in the solution to a problem
 patterns are not code or designs; must be instantiated/applied

 example: Iterator pattern

 The Iterator pattern defines an interface that declares methods
for sequentially accessing the objects in a collection.

4
 History of patterns
 the concept of a "pattern" was first expressed
in Christopher Alexander's work A Pattern
Language in 1977 (2543 patterns)

 in 1990 a group called the Gang of Four or "GoF"

(Gamma, Helm, Johnson, Vlissides) compile a
catalog of design patterns

 1995 book Design Patterns:

Elements of Reusable Object-Oriented
Software is a classic of the field

5
 Benefits of using patterns
 patterns are a common design vocabulary
 allows engineers to abstract a problem and talk about that
abstraction in isolation from its implementation
 embodies a culture; domain-specific patterns increase design
speed

 patterns capture design expertise and allow that

expertise to be communicated
 promotes design reuse and avoid mistakes

 improve documentation (less is needed) and

understandability (patterns are described well once)

6
 Gang of Four (GoF) patterns
 Creational Patterns
(abstracting the object-instantiation process)

Factory Method Abstract Factory Singleton

Builder Prototype

 Structural Patterns
(how objects/classes can be combined to form larger structures)

Adapter Bridge
Composite

Decorator Facade Flyweight

Proxy

 Behavioral Patterns
(communication between objects)

Command Interpreter Iterator

Mediator Observer State

Strategy Chain of Responsibility Visitor

Template Method 7
Pattern: Iterator
objects that traverse collections

8
Example:

9
 Iterator pattern
 iterator: an object that provides a standard way to
examine all elements of any collection
 uniform interface for traversing many different data structures
 supports concurrent iteration and element removal

for (Iterator<Account> itr = list.iterator(); itr.hasNext(); ) {

Account a = itr.next();
System.out.println(a); set.iterator()
} map.keySet().iterator()
map.values().iterator()

10
Pattern: Observer
objects whose state can be watched

11
 Recall: model and view
 model: classes in your system that are related to the
internal representation of the state of the system
 often part of the model is connected to file(s) or database(s)
 examples (card game): Card, Deck, Player
 examples (bank system): Account, User, UserList

 view: classes in your system that display the state of

the model to the user
 generally, this is your GUI (could also be a text UI)
 should not contain crucial application data
 Different views can represent the same data in different ways

Example: Bar chart vs. pie chart
 examples: PokerPanel, BankApplet

12
 Model-view-controller
 model-view-controller (MVC): common design
paradigm for graphical systems
 controller: classes that connect model and view
 defines how user interface reacts to user input (events)
 receives messages from view (where events come from)
 sends messages to model (tells what data to display)
 sometimes part of view (see left)

data for
renderin
Model View
g
View
Component
Model updates events
Controller
Controll
13
 Observer pattern
 observer: an object that "watches" the state of
another object and takes action when the state
changes in some way
 examples in Java: event listeners; java.util.Observer

 observable object: an object that allows observers to

examine it (often the observable object notifies the
observers when it changes)
 permits customizable, extensible event-based behavior for data
modeling and graphics

14
Observer sequence diagram

16
 Observer interface
package java.util;

public interface Observer {

public void update(Observable o, Object arg);
}

 Idea: The update method will be called when the

observable model changes, so put the appropriate code
to handle the change inside update

17
 Observable class
 public void addObserver(Observer o)
 public void deleteObserver(Observer o)
Adds/removes o to/from the list of objects that will be notified (via their
update method) when notifyObservers is called.

 public void notifyObservers()

 public void notifyObservers(Object arg)
Inform all observers listening to this Observable object of an event that
has occurred. An optional object argument may be passed to provide
more information about the event.

 public void setChanged()

Flags the observable object as having changed since the last event; must
be called each time before calling notifyObservers.

18
 Common usage of Observer
1. write a model class that extends Observable
 have the model notify its observers when anything significant
happens

2. make all views of that model (e.g. GUI panels that draw
the model on screen) into observers
 have the panels take action when the model notifies them of
events (e.g. repaint, play sound, show option dialog, etc.)

19
 Using multiple views
 make an Observable model

 write a View interface or abstract class

 make View an observer

 extend/implement View for all actual views

 give each its own unique inner components and code to draw
the model's state in its own way

 provide mechanism in GUI to set view (perhaps through

menus)
 to set view, attach it to observe the model

20
 Example: changing views

// in the frame's action listener:

// hide old view; show new one

model.deleteObserver(view1);
model.addObserver(view2);
view1.setVisible(false);
view2.setVisible(true);

21
 Pattern: Strategy
objects that hold alternate algorithms to solve a
problem

22
 Strategy pattern
 strategy: an algorithm separated from the object that
uses it, and encapsulated as its own object
 each strategy implements one behavior, one implementation of
how to solve the same problem
 separates algorithm for behavior from object that wants to act
 allows changing an object's behavior dynamically without
extending / changing the object itself

 examples:
 file saving/compression
 layout managers on GUI containers
 AI algorithms for computer game players

23
 Strategy example: Card player

// Strategy hierarchy parent

// (an interface or abstract class)
public interface Strategy {
public Card getMove();
}

// setting a strategy
player1.setStrategy(new SmartStrategy());

// using a strategy
Card p1move = player1.move(); // uses strategy

24
 Containers with layout
 The idea: Place many components into a special component called
a container, then add the container to the window frame

25
 Container
container: an object that holds components; it also
governs their positions, sizes, and resize behavior
 public void add(Component comp)
public void add(Component comp, Object info)
Adds a component to the container, possibly giving
extra information about where to place it.
 public void remove(Component comp)
Removes the given component from the container.
 public void setLayout(LayoutManager mgr)
Uses the given layout manager to position the
components in the container.
 public void validate()
You should call this if you change the contents of a
container that is already on the screen, to make it re-do
its layout.
26
 Pattern: Composite:
objects that can serve as containers, and can hold other objects like themselves
Composite pattern is used where we need to treat a group of objects in similar way as a
single object. Composite pattern composes objects in term of a tree structure to
represent part as well as whole hierarchy.

27
 Composite pattern
 composite: an object that is either an individual item
or a collection of many items
 composite objects can be composed of individual items or of
other composites
 recursive definition: objects that can hold themselves

 often leads to a tree structure of leaves and nodes:


<node> ::= <leafnode> |
<compositenode>

<compositenode> ::= <node>*

 examples in Java:
 collections (a List of Lists)
 GUI layout (panels containing panels containing buttons, etc.)

28
 Composite example: panels
Container north = new JPanel(new FlowLayout());
north.add(new JButton("Button 1"));
north.add(new JButton("Button 2"));

Container south = new JPanel(new BorderLayout());

south.add(new JLabel("Southwest"), BorderLayout.WEST);
south.add(new JLabel("Southeast"), BorderLayout.EAST);

// overall panel contains the smaller panels (composite)

JPanel overall = new JPanel(new BorderLayout());
overall.add(north, BorderLayout.NORTH);
overall.add(new JButton("Center Button"), BorderLayout.CENTER);
overall.add(south, BorderLayout.SOUTH);
frame.add(overall);

29
Pattern: Decorator
objects that wrap around other objects to add
useful features

30
 Decorator pattern
 decorator: an object that modifies behavior of, or adds
features to, another object
 decorator must maintain the common interface of the object it
wraps up
 used so that we can add features to an existing simple object
without needing to disrupt the interface that client code
expects when using the simple object
 the object being "decorated" usually does not explicitly know
about the decorator

 examples in Java:
 multilayered input streams adding useful I/O methods
 adding scroll bars to GUI controls

31
 Decorator example: I/O
 normal InputStream class has only public int
read() method to read one letter at a time
 decorators such as BufferedReader or Scanner add
additional functionality to read the stream more easily

// InputStreamReader/BufferedReader decorate InputStream

InputStream in = new FileInputStream("hardcode.txt");
InputStreamReader isr = new InputStreamReader(in);
BufferedReader br = new BufferedReader(isr);

// because of decorator streams, I can read an

// entire line from the file in one call
// (InputStream only provides public int read() )
String wholeLine = br.readLine();

32
 Decorator example: GUI
 normal GUI components don't have scroll bars
 JScrollPane is a container with scroll bars to which you
can add any component to make it scrollable

// JScrollPane decorates GUI components

JTextArea area = new JTextArea(20, 30);
JScrollPane scrollPane = new JScrollPane(area);
contentPane.add(scrollPane);

 JComponents also have a setBorder method to add a

"decorative" border. Is this another example of the Decorator
pattern? Why or why not?

33
 References
 The Java Tutorial: Visual Index to the Swing Components.
http://java.sun.com/docs/books/tutorial/
uiswing/components/components.html

 The Java Tutorial: Laying Out Components Within a Container.

http://java.sun.com/docs/books/tutorial/uiswing/
layout/index.html

 Java Class Library Reference: Observer, Observable.

http://java.sun.com/j2se/1.5.0/docs/api/java/util/Observer.html
http://java.sun.com/j2se/1.5.0/docs/api/java/util/Observable.html

 Cunningham & Cunningham OO Consultancy, Inc.

 http://c2.com/cgi/wiki?IteratorPattern
 http://c2.com/cgi/wiki?DecoratorPattern
 http://c2.com/cgi/wiki?CompositePattern

 Design Patterns Java Companion

 http://www.patterndepot.com/put/8/JavaPatterns.htm
34