Art for Chapter 8, Object Design: Reusing Pattern Solutions

Usi

ng U

ML

, Pat

tern

s, a

nd J

ava

Ob

ject

-Ori

ente

d S

oftw

are

En

gin

eeri

ng Art for Chapter 8,

Object Design:Reusing Pattern Solutions

Bernd Bruegge & Allen H. Dutoit Object-Oriented Software Engineering: Using UML, Patterns, and Java 2

Problem

Machine

System design gap

Object design gap

Requirements gap

System

Application objects

Solution objects

Custom objects

Off-the-shelf components

Figure 8-1, Object design closes the gap between application objects identified during requirements and off-the-shelf components selected during system design.

Bernd Bruegge & Allen Dutoit Object-Oriented Software Engineering: Conquering Complex and Changing Systems 3

Figure 8-2, Activities of object design (continued on next slide).

Specifying constraints

Specifying types &signatures

Identifying patterns

Adjusting patterns

Identifying missingattributes & operations

Specifying visibility

Specification

Specifying exceptions

Reuse

Identifying components

Adjusting components

Select Subsystem


Figure 8-2, Continued.

Collapsing classes

Restructuring Optimization

Revisitinginheritance

Optimizing accesspaths

Caching complexcomputations

Delaying complexcomputations

Check Use Cases

Realizing associations


Figure 8-3, An example of implementation inheritance (continued on next slide).

Hashtable

MySet

put(element)containsValue(element):boolean

put(key,element)get(key):ObjectcontainsKey(key):booleancontainsValue(element):boolean

Object design model before transformation Object design model after transformation

Hashtable

MySet

put(element)containsValue(element):boolean

put(key,element)get(key):ObjectcontainsKey(key):booleancontainsValue(element):boolean

table 1

1


Figure 8-3, continued.

/* Implementation of MySet using inheritance */

class MySet extends Hashtable {

/* Constructor omitted */

MySet() {

}

void put(Object element) {

if (!containsKey(element)){

put(element, this);

}

}

boolean containsValue(Object

element){

return containsKey(element);

}

/* Other methods omitted */

}

/* Implementation of MySet using delegation */

class MySet {

private Hashtable table;

MySet() {

table = Hashtable();

}

void put(Object element) {

if (!containsValue(element)){

table.put(element,this);

}

}

boolean containsValue(Object

element) {

return

(table.containsKey(element));

}

/* Other methods omitted */

}


Figure 8-4, Inheritance meta-model.

Inheritance

SpecificationInheritance

ImplementationInheritance

Inheritancefor ReuseTaxonomy

Inheritance detectedduring generalization

Inheritance detectedduring specialization


Figure 8-5, An example of design pattern: Adapter.

ClientInterface

Request()

adaptee

LegacyClass

ExistingRequest()

Adapter

Request()

Client


Figure 8-6, Applying the Adapter design pattern to the Set problem of Figure 8-3.

Set

add(element)

adaptee

Hashtable

put(key,element)

MySet

add(element)

Client


Figure 8-7, Applying the Bridge design pattern for abstracting database vendors.

LeagueStoreImplementorLeagueStoreimp

XML StoreImplementor

Stub StoreImplementor

JDBC StoreImplementor

Arena


Figure 8-8, Applying the Adapter design pattern for sorting Strings in an Array. See source code in Figure 8-9.

Comparator

compare()

adaptee

MyString

MyStringComparator

compare()

greaterThan()equals()

Array


Figure 8-9, Adapter design pattern example.

/* Existing target interface */

interface Comparator {

int compare(Object o1, Object o2);

/* ... */

}

/* Existing client */

class Array {

static void sort(Object [] a, Comparator c);

/* ... */

}

/* Existing adaptee class */

class MyString extends String {

boolean equals(Object o);

boolean greaterThan(MyString s);

/* ... */

}

/* New adapter class */

class MyStringComparator implements Comparator {

/* ... */

int compare(Object o1, Object o2) {

int result;

if (o1.greaterThan(o2)) {

result = 1

} else if (o1.equals(o2)) {

result = 0;

} else {

result = -1;

}

return result;

}

}


Figure 8-10, Applying the Strategy pattern for encapsulating multiple implementations of a NetworkInterface.

NetworkInterface

open()close()send()receive()

NetworkConnection

send()receive()setNetworkInterface()LocationManager

Application

Ethernet


WaveLAN


UMTS



Figure 8-12, Applying the Abstract Factory design pattern to different intelligent house platforms

HouseFactory

LightBulb

EIBBulb LuxmateBulb

LuxmateFactoryEIBFactory

createBulb()createBlind()

Blind

EIBBulb LuxmateBulb

TheftApplication




Figure 8-13, Applying the Command design pattern to Matches in ARENA.

GameBoard

«binds»TicTacToeMove

execute()

ChessMove

execute()

Move

execute()

Match *

replay()play()


Figure 8-14, Anatomy of a preference dialog. Aggregates, called Panels, are used for grouping user interface objects that need to be resized and moved together.

Top panel

Main panel

Button panel


Figure 8-15, UML object diagram for the user interface objects of Figure 8-14.

top:Panel

prefs:Window

ok:Button

main:Panel buttons:Panel

title:Label

c2:Checkbox

c3:Checkbox

c4:Checkbox

cancel:Button

c1:Checkbox


Figure 8-16, Applying the Composite design pattern to user interface widgets.

Component*

CheckboxButton CompositeLabel

PanelWindow

Applet

move()resize()

move()resize()


Figure 8-17, An example of dynamic site with WebObjects.

WebBrowser

RelationalDatabase

StaticHTML

WOAdaptorWebServer

WoRequestTemplate

WebObjectsApplication

WORequest

EOF


Figure 8-18, WebObject’s State Management Classes. The HTTP protocol is inherently stateless.

WOSession WOComponent DynamicElement

WOApplication

WORequest

WOAdaptor

*

*

**

WebServer WOSessionStore

*


Figure 8-19, ARENA analysis objects related to Game independence.

League

Tournament

Match

Game

Arena

LeagueOwner

Player

Move

Result

Statistics

TicTacToe

Chess


Figure 8-20, Applying the Abstract Factory pattern to Games

Game

Match

TTTMatch ChessMatch

ChessTicTacToe


Statistics

TTTStats ChessStats

Tournament

createMatch()createStatistics()



Figure 8-21, Applying the Command design pattern to Matches and ReplayedMatches in ARENA.

replay()

«binds»

play()

TicTacToeMove

ChessMove

Move

execute()

Match *

GameBoard

nextMove()

ReplayedMatch

previousMove()


Figure 8-22, Applying the Observer design pattern to maintain consistency across MatchViews.

GameBoard

stategetState()playMove()

Observer

update()

MatchView

gameBoardupdate()

observers

*1Subject

subscribe(Subscriber)unsubscribe(Subscriber)notify()

Documents

Art for Chapter 8, Object Design: Reusing Pattern Solutions