1. Structural Design Patterns
Yaodong Bi
November 11, 2018

2. Structural design patterns
Façade
Decorator
Composite
Proxy
Adapter
Bridge
Flyweight

3. Façade Design Purpose Design Pattern Summary
Provide a single and simple interface to a package of classes
Design Pattern Summary
Define a single and simple interface for clients to use the functionality of the package

4. Façade - examples A compiler package
It normally contains many classes/subpackages like Scanner, Parser, etc.
Most clients only want to compile their programs, i.e., they don’t care about functions of individual components in the package
Use Façade to provide a simple default interface to most clients.

5. Façade - Structure Client Facade ClassA ClassC ClassB
Use op1(), op2(), op3(), and op4()
Facade
op1()
op2()
op3()
op4()
ClassA
op3_a()
ClassC
op4_c()
ClassB
op1_b()
op2_b()

6. Sequence Diagram Client Facade B:ClassB A:ClassA C:ClassC op1()
op1_b()
op3()
op3_a()
op4()
op4_c()
op2()
op2_b()

7. Façade - Structure Client Compiler ProgramNodeBuilder Scanner Parser
Compiler.compile(“test.c”)
Compiler
compile()
ProgramNodeBuilder
Scanner
Parser
CodeGenerator

8. Façade – Sample code Class Compiler {
Class Scanner {
public Scanner(InputStream sourcecode)
public Token scan() { … } }
Class Parser {
public parse(Scanner s, ProgramNodeBudiler p) { … }
Class ProgramNodeBuilder {
public ProgramNode newVariable(…) { … }
public ProgramNode newAssignment(…) { … }
public ProgramNode newReturnStmt(…) { … }
Class CodeGenerator {
public void visitStatementNode(…) { … }
public void visitExpressionNode(…) { … }
Class Compiler {
public void compile(InputStream sc,
OutputStream bytecode) {
Scanner sc = new Scanner(sc);
ProgramNodeBuilder pnb = new
ProgramNodeBuilder();
Parser parser = new Parser();
parser.parse(sc, pnb);
IntelCodeGenerator cg = new
IntelCodeGenerator(bytecode)
ProgramNode nodetree = pnb.getRootNode();
parsetree.traverse(cg); }

9. Façade - Examples Client BankCustomers framework Customer Account
getCustomerName()
getNumAccounts()
getPersonalNote()
getAccount( int )
AccountException
Account
getAccountNum()
deposit( int )
getBalance()
CustomerException
BankCustomers
1..n
BankCustomer
BankAccount
Client
BankCustomers
doDeposit( int amt, Customer cust, Account acc )
getBankAccount( Customer cust, int accNum )
getBankCustomer( String custName )

10. Façade - comments
Façade can reduce the degree of dependency between packages
Packages are dependent on each other only through their facades, not individual classes
Use Façade to provide a simple default view of the package that is enough for most clients
Façade does not try to encapsulate/hide the components in the package since there may be clients who need to access individual components in the package

11. Decorator Design Purpose Design Pattern Summary
Add responsibilities to an object at runtime.
Design Pattern Summary
Provide for a linked list of objects, each encapsulating responsibility.

12. Decorator - examples The word processor example
A text view may have a border and a scroll bar and maybe other bells and whistles attached to it
How can those bells and whistles be added to the text view?
Inheritance?

13. Decorator – structure Component Client ConcreteComp Decorator comp
operation()
add(Component)
remove(Component)
getChild()
Client
ConcreteComp
operation()
Decorator
Operation()
comp
void operation() {
// do actions of the decorator
comp.operation(); }

14. Decorator - example

15. Decorator – structure Client VisualComponent TextView Decorator
draw()
Client
TextView
draw()
Decorator
draw()
comp
comp.draw()
ScrollDecorator
draw()
scrollTo()
scrollPosition
BorderDescrotor
draw()
drawBorder()
borderWidth
super.draw()
this.drawBorder()

16. Decorator – examples
Client
:Decorator1
:Decorator2
:ConcreteComp

17. Decorator - Sequence Diagram
Client
Component
:Decorator1
:Decorator2
:ConcreteComp
operation()
operation()
operation()
operation()
return
return
return
return

18. Decorator – examples 1 :Reader : BufferedStreamReader
:InputStreamReader
System.in:InputStream

19. Decorator – examples : BufferedStreamReader :InputStreamReader
System.in:InputStream

20. Decorator – key concept
allows addition to and removal from objects at runtime

21. Decorator – sample code
class VisualComponent {
virtual void Draw();
virtual void Resize(); };
class Decorator : public VisualComponent {
Decorator(VisualComponent*);
void Decorator::Draw () {
_component->Draw(); }
VisualComponent* _component;
class BorderDecorator : public Decorator {
BorderDecorator(VisualComponent*, int borderWidth);
void Draw(){
Decorator::Draw();
DrawBorder(_width);
private void DrawBorder(int);
private int _width;
Class Window {
void SetContents (VisualComponent* contents) {
// ... }
Window* window = new Window();
TextView* textView = new TextView;
window->SetContents(textView);
window->SetContents(
new BorderDecorator(
new ScrollDecorator(textView), 1 ) );
Window.draw();

22. Composite Design Purpose Design Pattern Summary
Represent a Tree of Objects
Design Pattern Summary
Use a Recursive Form in which the tree class aggregates and inherits from the base class for the objects.

23. Composite - structure Objects Classes Component NonLeafNode 1..n
“non-leaf nodes have one or more components”
“every object involved
is a Component object”
leaf node
NonLeafNode

24. Composite - structure Client Component 1..n LeafNode doIt()
add( Component )
Remove(component)
doIt()
1..n
Client
comp
LeafNode
doIt()
NonLeafNode
doIt()
for all elements e in comp
e.doIt()
TypeANonLeafNode
doIt()
TypeBNonLeafNode
doIt()

25. Composite – A Class Diagram
:Client
N0:NonLeafNode
N1:NonLeafNode
N2:NonLeafNode
L3:LeafNode
L2:LeafNode
L1:LeafNode

26. Composite – sequence diagram
:Client
N0:NonLeafNode
N1:NonLeafNode
L1:LeafNode
L2:LeafNode
L3:LeafNode
N2:NonLeafNode
doIt()
doIt()
doIt()
doIt()
doIt()
doIt()

27. Composite – examples Component 1..n Container component … . . Window
Composite in java.awt
Container
component
… . .
Window
Canvas

28. Proxy Design Purpose Design Pattern Summary
Avoid the unnecessary execution of expensive functionality in a manner transparent to clients.
Design Pattern Summary
Interpose a substitute class which accesses the expensive functionality only when required.

29. Proxy – examples BaseActiveClass Client Instantiate with Proxy object
expensiveMethod()
anotherMethod()
Client
RealActiveClass
expensiveMethod()
anotherMethod()
Proxy
expensiveMethod()
anotherMethod()
if ( realActiveObject == null ) // not loaded yet
{ realActiveObject = getRealActiveObject();
realActiveObject.expensiveMethod(); }
else { realActiveObject.expensiveMethod(); }

30. Proxy – sequence diagram
Client
BaseActiveClass
Proxy
RealActiveClass
expensiveMethod()
create() if needed
expensiveMethod()

31. Proxy – examples TexDoc Graphics Image graphics Display() display()
Instantiate with
Proxy object
TexDoc
graphics
Graphics
Display()
Image
display()
bitmap
ImageProxy
display()
fileName
image
if ( image == null ) { // not loaded yet
image = new Image(fileName); }
Image.display();

32. Proxy – Sample code Class TextDoc { graphics g; Interface Graphics {
TextDoc(Graphics ip) {
g = ip; }
void display() {
g.display();
Class ImageProxy implements Graphics {
FileName fileName;
Image image;
ImageProxy(FileName fn) {
fileName = fn;
display() {
if (image == null)
image = new Image(fileName);
image.display();
Interface Graphics {
display(); }
Class Image Implements Graphics {
Bitmap bitmap;
Image(FileName fn) {
bitmap = readImage(fn);
display() {
// draw the bitmap
readImage(FileName fn) {
// read from the file(fn)
// create a bitmap

33. Adapter Design Purpose Design Pattern Summary
Allow an application to use external functionality in a retargetable manner.
Design Pattern Summary
Write the application against an abstract version of the external class; introduce a subclass that aggregate the external class.

34. Adapter - examples Interact with legacy systems
When you design a new system which has to interact with a legacy system, you may not want to the new system tightly coupled with (or dependent upon) the legacy system since the legacy system may be replaced in the future.
Using 3rd party systems
You may want to be able to easily substitute the current 3rd party system with another one.

35. Class Adapter

36. Object Adapter - Structure
Target
+request()
Client
Adaptee
+requestedMethod();
adaptee
Adapter
+request()
adaptee.requestedMethod()

37. Adapter – sequence diagram
Client
Target
Adapter
Adaptee
request(TargetIn):TargetOut
request(TargetIn):TargetOut
convert(TargetIn):AdapteeIn
requestedMethod(AdapteeIn):AdapteeOut
Return TargetOut
Return TargetOut
convert(AdapteeOut):TargetOut

38. Object Adapter – sample code
Interface Target {
public TargetOut request(TargetIn); }
Class Adaptee { …
public AdapteeOut
requestedMethod(AdapteeIn) {
// produce AdapteeOut;
return AdapteeOut;
Class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee ad) {
adaptee = ad; }
public TargetOut request(TargetIn ti) {
AdapteeIn ai = convert(ti);
AdapteeOut ao =
adaptee.requestedMethod(ai);
return convert(ao);
private AdapteeIn convert(TargetIn ti) {
// convert TargetIn to AdapteeIn
private TargetOut convert(AdapteeOut ao)
// convert AdapteeOut to TargetOut

39. Object Adapter - Example
Shape
+boundingBox()
+createManipulator()
DrawingTool
TextView
+getExtent();
text
TextShape
+boundingBox()
+createManipulator()
text.getExtent()
return new TextManipulator()

40. Design for Adaption Pluggable Adapters
A small set of operations is specified for adapter & adaptee to implement
Using Abstract Operations
Client and target are the same entity
Adapter overrides abstract operations to delegate operations to adaptee
Using Delegate Objects
A delegate interface specifies operations the adapter needs to implement

41. Using Abstract Operations

42. Using Delegate Objects

43. Adapter - comments An adapter may have more than one adaptee
There may not be a one-to-one correspondence between operations of Target and those of Adaptee
So it is possible that an operation of Target is realized with two separate adaptee classes.
The pattern decouples Client from adaptee.
When a different adaptee is needed, we only need to change to another adapter and the client does not need to change at all.

44. Structural Patterns - Summary
Facade provides an interface to collections of objects
Decorator adds to objects at runtime
Composite represents trees of objects
Proxy avoids calling expensive operations unnecessarily
Adapter decouples client from an existing system