CS 4240: Introduction to Design Patterns

Readings: Chap. 5 of Design Patterns Explained Also, Chap. 6 and 7 Also, on-line info on Composite pattern (and others) at http://www.oodesign.com

Readings

Chapter 5 of our textbook Handouts on various patterns

Background, Definition

From Alexander’s work in architecture Alexander: “a solution to a problem in

context.” Design pattern: a description of a problem

that reoccurs and an outline of an approach to solving that problem Generally domain, language independent Also, analysis patterns

Design Patterns: Essential Elements Pattern name

A vocabulary of patterns is beneficial Intent Problem

When to apply the pattern, what context. How to represent, organize components Conditions to be met before using

Solution Design elements: relationships, responsibilities, collaborations A template for a solution that you implement

Consequences Results and trade-offs that result from using the pattern Needed to evaluate design alternatives

Essential Elements (con’td)

Participants and collaborators Implementation Generic Structure

Patterns Are (and Aren’t)

Name and description of a proven solution to a problem

Documentation of a design decision They’re not:

Reusable code, class libraries, etc. (At a higher level)

Do not require complex implementations Always the best solution to a given situation Simply “a good thing to do”

Describing Design Patterns The GoF defined a standard format

Generally followed Not just a UML diagram!

Pattern Format (13 sections): Pattern name and classification Intent: what’s it do? Rationale? Also known as Motivation

A scenario that illustrates a sample problem and how this patterns helps solve it.

Applicability For which situations can this be applied?

Structure Graphical representation (e.g. UML)

Pattern Format (cont’d) Participants

Classes and objects, their responsibilities Collaborations

How participants interact Consequences Implementation

Pitfalls, hints, techniques, language issues Sample code

Code fragments that illustrate the pattern Known uses

From real systems Related patterns

Similar patterns, collaborating patterns

Example 1: Singleton Pattern

Global variables are bad! Why?

We often want to use global variables! Why?

Example 1: Singleton Pattern Context: Only one instance of a class is created.

Everything in the system that needs this class interacts with that one object.

Controlling access: Make this instance accessible to all clients

Solution: The class has a static variable called theInstance (etc) The constructor is made private (or protected) Clients call a public operation getInstance() that returns the

one instance This may construct the instance the very first time or be given

an initializer

Singleton: Java implementation

public class MySingleton {

private static MySingleton theInstance =

new MySingleton();

private MySingleton() { // constructor

…

}

public static MySingleton getInstance() {

return theInstance;

}

}

Static Factory Methods

Singleton patterns uses a static factory method Factory: something that creates an instance

Advantages over a public constructor They have names. Example:

BigInteger(int, int, random) vs.BigInteger.probablePrime()

Might need more than one constructor with same/similar signatures

Can return objects of a subtype (if needed) Wrapper class example:

Double d1 = Double .valueOf(“3.14”); Double d2 = new Double (“3.14”);

More info: Bloch’s Effective Java

Examples from Java Library

In Swing, you can create a Border and add it to a componentBorder b =

BorderFactory.createBevelBorder(3); Need the exact same border again? The above method doesn’t create a new

one. Just gives you the same one Note: works because the bevel is

immutable

Example from the Java Library

Java can manipulate its own class definitions

Example:Class classObj =

Class.forName(“edu.uva.cs441.MyClass”); Then we can do things to the Class

object What if we call this again? Only one Class object per Java-class

Example #2: PlayLists and Songs

We saw this in CS201 (maybe)

Could PlayLists “Nest”?

Could a PlayList contain Songs and other PlayLists?

This is the “Composite Design Pattern” Make PlayList contain

A list of PlayableItems, not Songs PlayList.play() calls play() on each item Polymorphism at work

Class Diagram for This Composite

General Class Diagram

Could be many Leaf classes

Polymorphism in Action

Playlist contains a list of PlayableItems PlayList.play() calls play() on each item

for (int i=0; i<list.size(); ++i) { ( (PlayableItem) list.get(i) ).play(); }

Will call the Song.play() or PlayList.play() depending on what item i really is Review question: why is the cast needed?

Façade Pattern Intent:

Simplify interface to set of interfaces in an existing subsystem.Or, need to define new/variant interface

Problem: Only need part of a complex system.

Or, need to interact in a particular way. Participants, collaborators:

Façade class, subsystem classes, client class

Façade Pattern (cont’d)

Consequences: Certain subsystem operations may not be

available in the façade Clients may “go around” the facade

Note in textbook

Reduce coupling for client Existing interfaces requires client to

access many objects to carry out task Façade object may be one object that’s a

“gateway” to multiple objects In other words: the Façade encapsulates

the system Another motto: find what varies and

encapsulate it

Examples:

Java’s URL class Really hides a set of objects and methods But not easy to see that it does this IMHO

An example from our recent CS1110 textbook Make I/O easier for beginners Class StdIn: static methods to read Class In: create object to read from

keyboard, file or URL

Class In from Princeton course textSee Javadoc here:

http://www.cs.princeton.edu/introcs/stdlib/javadoc/In.html

Encapsulate Scanner, simplify methods

public final class In { private Scanner scanner;

...

public In() { scanner = new Scanner(

new BufferedInputStream(System.in), charsetName); scanner.useLocale(usLocale); }

... /** * Is the input stream empty? */ public boolean isEmpty() { return !scanner.hasNext(); }

Create “reader” from filename or URL public In(String s) { try { // first try to read file from local file system File file = new File(s); if (file.exists()) { scanner = new Scanner(file, charsetName); scanner.useLocale(usLocale); return; } // next try for files included in jar URL url = getClass().getResource(s); // or URL from web if (url == null) { url = new URL(s); } URLConnection site = url.openConnection(); InputStream is = site.getInputStream(); scanner = new Scanner(

new BufferedInputStream(is), charsetName); scanner.useLocale(usLocale); } catch (IOException ioe) { System.err.println("Could not open " + s); } }

Think About and Discuss

Façade: any relation to the Law of Demeter?

“Principle of Least Knowledge” Talk only your immediate friends

Adaptor Pattern Intent:

Make an existing object match an existing interface that it doesn’t match

Problem: Existing component has right functionality but

doesn’t match the interface used Interface here? Abstract class (or Java-interface)

used polymorphically Solution:

Wrapper class with delegation etc. Two flavors: Object Adaptor vs. Class Adaptor

Adaptor Pattern (cont’d) Participants and Collaborators

Adapter class: “new” interface for… Adaptee class (existing class) Target: the needed interface Client who uses objects of type Target

Consequences: The good: solves problem and meets

intent above! Some other wrinkles…

Class Diagram for Object Adaptor

Object Adaptor pattern Note that Adapter is an

example of a “wrapper class” A common implementation technique

used in several design patterns

Book’s Example

Abstract class (or interface) Shape Methods include: display(), fill() Our code relies on Shape hierarchy and

polymorphism We need a Circle class

Sweet! Another one exists! XXCircle Bummer! Method names are different

Solution: see book or notes on board

Class Adaptor Pattern

Don’t create a separate object that wraps the existing object

Instead, create new class that Includes what existing class has (inherit) Also meets Target interface

With a Java interface, or multiple inheritance in other languages

Class Adaptor example

Problem: Existing code has a CommandBuffer class Doesn’t have an Iterator You have code that could do great things if

only you could use CommandBuffer as if it were Iterable

Example of Class Adaptor pattern

The new class implements Iterator methods in terms of getCommand() etc defined in existing class

No pair of objects: just an instance of new class

Think About and Discuss

Class adaptors are different than object adaptors

Does this difference relate to a “rule” or “principle” of OO design we’ve seen?

Comparing Façade and Adaptor Similarities:

Both designed to help us use existing classes better

Both can use wrapper objects Similar implementation solves different problems

Adaptor: existing interface we must design to (not for Façade) New object used polymorphically

Façade: need simpler interface (not a goal for Adaptor)

See table 7-1 on page 110

Summary of Intro to Design Patterns Understand background, general

principles of design patterns Examples:

Singleton Composite Façade Adaptor

Recognize them, apply them in simple situations

Exercise: Can you Adapt?

Deprecated Java interface Enumerator hasMoreElements() nextElement()

Replaced by interface Iterator hasNext() next() remove()

Your task

Create a class: EnumerationIterator This let us design and write new code

that works with Iterators, andalso interact with legacy code that exposes Enumerators for use to use

First question: class or object adaptor?

Questions to Answer

Question: which classes play which roles in the design pattern? Write this down.

Final question: write Java class with constructor and next() and hasNext().