1

TCSS 360, Spring 2005Lecture Notes

Design Patterns:Factory, Command

2

Outline

What are design patterns? Why should we study them?

List of all design pattern names and categories

Factory pattern

Command pattern

3

Design challenges Designing software for reuse is hard; one must find:

a good problem decomposition, and the right software abstractions

a design with flexibility, modularity and elegance

designs often emerge from an iterative process (trials and many errors)

successful designs do exist two designs they are almost never identical they exhibit some recurring characteristics

The engineering perspective: can designs be described, codified or standardized?

this would short circuit the trial and error phase produce "better" software faster

4

Design patterns history

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

design pattern: a solution to a common software problem in a context example: Iterator pattern

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

5

More about patterns A pattern describes a recurring software structure

is abstract from concrete design elements such as problem domain, programming language

identifies classes that play a role in the solution to a problem, describes their collaborations and responsibilities

lists implementation trade-offs patterns are not code or designs; must be instantiated/applied

the software engineer is required to: evaluate trade-offs and impact of using a pattern in the system

at hand make design and implementation decision how best to apply

the pattern, perhaps modify it slightly implement the pattern in code and combine it with other

patterns

6

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)

7

Gang of Four (GoF) patterns

Creational Patterns(concerned with abstracting the object-instantiation process)

Factory Method Abstract Factory Singleton Builder Prototype

Structural Patterns(concerned with how objects/classes can be combined to form larger structures)

Adapter BridgeComposite

Decorator Facade Flyweight Proxy

Behavioral Patterns(concerned with communication between objects)

Command Interpreter Iterator Mediator Observer State Strategy Chain of Responsibility Visitor Template Method

8

Pattern: Factory(a variation of Factory Method, Abstract Factory)

a class used to create other objects

9

Problem: Bulky GUI code GUI code to construct many components

quickly becomes redundant (here, with menus): homestarItem = new JMenuItem("Homestar Runner"); homestarItem.addActionListener(this); viewMenu.add(homestarItem); crapItem = new JMenuItem("Crappy"); crapItem.addActionListener(this); viewMenu.add(crapItem);

another example (with buttons): button1 = new JButton(); button1.addActionListener(this); button1.setBorderPainted(false);

button2 = new JButton(); button2.addActionListener(this); button2.setBorderPainted(false);

10

Factory pattern Factory: a class whose sole job is to easily

create and return instances of other classes

a creational pattern; makes it easier to construct complex objects

instead of calling a constructor, use a static method in a "factory" class to set up the object

saves lines and complexity to quickly construct / initialize objects

examples in Java: borders (BorderFactory), key strokes (KeyStroke), network connections (SocketFactory)

11

Using existing factories in Java

setting borders on buttons and panels use built-in BorderFactory class

myButton.setBorder(

BorderFactory.createRaisedBevelBorder());

setting hot-key "accelerators" on menus use built-in KeyStroke class

menuItem.setAccelerator( KeyStroke.getKeyStroke('T',

KeyEvent.ALT_MASK));

12

Factory implementation details

when implementing a factory of your own: the factory itself should not be instantiated

make constructor private factory only uses static methods to construct

components factory should offer as simple an interface to

client code as possible don't demand lots of arguments; possibly overload

factory methods to handle special cases that need more arguments

factories are often designed for reuse on a later project or for general use throughout your system

13

Factory sequence diagram

14

Factory examplepublic class ButtonFactory { private ButtonFactory() {}

public static JButton createButton( String text, ActionListener listener, Container panel)

{ JButton button = new JButton(text); button.setMnemonic(text.charAt(0)); button.addActionListener(listener); panel.add(button); return button; }}

15

GoF's variations on Factory

Factory Method pattern: a factory that can be constructed and has an overridable method to create its objects can be subclassed to make new kinds of factories

Abstract Factory pattern: when the topmost factory class and its creational method are abstract

16

Pattern: Command

objects that represent actions

17

Open-closed principle Open-Closed Principle: Software entities like

classes, modules and functions should be open for extension but closed for modifications.

The Open-Closed Principle encourages software developers to design and write code in a fashion that adding new functionality would involve minimal changes to existing code. most changes will be handled as new methods and

new classes designs following this principle would result in

resilient code which does not break on addition of new functionality

18

Bad event-handling codepublic class TTTGui implements ActionListener { ...

public void actionPerformed(ActionEvent event) { if (event.getSource() == view1Item){

// switch to view #1 ...

else { // event source must be view2Item

// switch to view #2 ...

} }}

in this code, the "master" TTT GUI object is in charge of all action events in the UI is this bad? what could happen if we add another action event

source?

19

Common UI commands it is common in a GUI to have several ways to

activate the same behavior example: toolbar "Cut" button and "Edit / Cut" menu this is good ; it makes the program flexible for the

user we'd like to make sure the code implementing these

common commands is not duplicated

20

Solution: Action,AbstractAction

Java's Action interface represents a UI command a UI command has a text name, an icon, an action to run can define multiple UI widgets that share a common

underlying command by attaching the same Action to them These Swing components support Action

JButton(Action a) JToggleButton(Action a) JCheckBox(Action a) JMenuItem(Action a) JRadioButton(Action a)

AbstractAction class implements Action and maintains an internal map of keys to values

each key represents a name of a property of the action (e.g. "Name") each value represents the value for that property (e.g. "Save Game") can be used to ensure that all UI components that share a common UI

action will have the same text, icon, hotkey

21

ActionListener and Action code

reminder: interface ActionListener public void actionPerformed(ActionEvent e)

interface Action extends ActionListener adds property enabled

isEnabled() / setEnabled(boolean)

abstract class AbstractAction implements Action you must still write actionPerformed

22

AbstractAction members public class AbstractAction implements Action

public AbstractAction(String name) public AbstractAction(String name, Icon icon) public Object getValue(String key) public boolean isEnabled() public void putValue(String key, Object value) public void setEnabled(boolean enabled) ...

AbstractAction object maintains an internal map of keys to values

each key represents a name of a property of the action (e.g. "Name")

each value represents the value for that property (e.g. "Save Game")

23

Using Action, example define a class that extends AbstractAction: public class CutAction extends AbstractAction { public CutAction() { super("Cut", new ImageIcon("cut.gif")); }

public void actionPerformed(ActionEvent e) { // do the action here ... } }

create an object of this class, attach it to UI objects: CutAction cut = new CutAction(); JButton cutButton = new JButton(cut); JMenuItem cutMItem = new JMenuItem(cut);

now the same action will occur in both places; also, changes to the action will be seen on both widgets:

cut.setEnabled(false);

24

Action and Swing components

Other uses: properties of the action can be set cut.putValue(Action.SHORT_DESCRIPTION, "Cuts the selected text");

will use this label for the tooltip text

cut.putValue(Action.NAME, "Cut"); will use the text label "Cut" for the name of the command

cut.putValue(Action.MNEMONIC_KEY, new Integer('T'));

will underline 't' in "Cut" as a mnemonic hotkey for the command

cut.putValue(Action. ACCELERATOR_KEY, KeyStroke.getKeyStroke('X', KeyEvent.CTRL_MASK));

will use Ctrl-X as an accelerator hotkey for the command

25

Command pattern Command: an object that represents an

action sometimes called a "functor" to represent an

object whose sole goal is to encapsulate one function

Java API examples: ActionListener, Comparator, Runnable / Thread

26

Command pattern applications

command objects serve as a "model" of commands: separates the user interface from them each model can support multiple views each action can support multiple widgets

use the Command pattern when you want to: implement a callback function capability have several UI widgets that cause the same action

to occur specify, queue, and execute requests at different

times support undo and change log operations

27

References Java API pages

http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/Action.html http://java.sun.com/j2se/1.4.2/docs/api/javax/swing/

AbstractAction.html

Cunningham & Cunningham OO Consultancy, Inc. http://c2.com/cgi/wiki?AbstractFactoryPattern http://c2.com/cgi/wiki?FactoryMethodPattern http://c2.com/cgi/wiki?CommandPattern

Design Patterns Java Companion http://www.patterndepot.com/put/8/JavaPatterns.htm

Design Pattern Synopses http://www.mindspring.com/~mgrand/pattern_synopses.htm