introduction to design patterns why a design pattern · 6 creational pattern factory method: define...

1

Introduction to Design Patterns

Nasreddine Aoumeur

E-mail: [email protected]

Why a Design PatternReusability: one of the basis for an efficientand actual SE discipline

Helping new designers to have a moreflexible and reusable design

Improving the documentation andmaintenance of existing system by furnishingan explicit specification of class and objectinteractions and their intent.

History of Design Pattern1979: Christopher Alexander,architect, “TheTimeless Way of Building”, Oxford Press

1987: OOPSLA (Object Oriented ProgrammingSystem),Orlando, presentation of designpattern to the community OO by WardCunningham and Kent Beck.

Pattern origins and historyKent Beck and Ward Cunningham, Textronix,OOPSLA'87(used Alexander's "pattern" ideas for SmalltalkGUI design)Erich Gamma, Ph. D. thesis, 1988-1991James Coplien, Advanced C++ Idioms book,1989-1991PLoP Conferences and books, 1994-presentBuschmann, Meunier, Rohnert, Sommerland,Stal, Pattern -Oriented Software Architecture:A System of Patterns ((““POSA bookPOSA book””))1995: Group of Four alias E.Gamma,R.Helm,R.Johnson and J.Vlissides : “DesignPattern:Elements of Reusable OO software”

Definition… a fully realized form, original, or model accepted orproposed for imitation…[dictionary]... describes a problem which occurs over and overagain in our environment, and then describes the coreof the solution to that problem, in such a way thatyou can use this solution a million times over, withoutever doing it the same way twice [Alexander]… the abstraction from a concrete form which keepsrecurring in specific non-arbitrary contexts [Riehle]

…both a thing and the instructions for making thething [Coplien]

...a literary format for capturing the wisdom andexperience of expert designers, and communicating itto novices

Properties

Patterns do...Patterns do...provide common vocabularyprovide “shorthand” for effectively communicatingcomplex principleshelp document software architecturecapture essential parts of a design in compact formshow more than one solutiondescribe software abstractions

Patterns do not...Patterns do not...provide an exact solutionsolve all design problemsonly apply for object-oriented design

2

Patterns can be

non-generative (Gamma patterns) observed in a system descriptive and passive

generative generate systems or parts of systems perspective and active

Ingredients

Pattern

Solution

Problem

Context

a design situation giving rise to a design problem

a form or rule that can be applied to resolve these forces

a set of forces occuring in that context

Example Example –– window place window placeforces he wants to sit down and be comfortable he is drawn toward the light

solution in every room, make at least one window into a

“window place”

Types of software patterns

design patterns (software design)[Buschmann-POSA] architectural (systems design) design (micro-architectures) [Gamma-GoF] idioms (low level)

analysis patterns (recurring & reusable analysismodels) [Flower]organization patterns (structure oforganizations/projects)process patterns (software process design)domain-specific patterns (ditribution, evolution,…)

Alexandrian form (canonical form)

Name : meaningful nameProblem : the statement of the problemContext : a situation giving rise to a problemForces : a description of relevant forces and

constraintsSolution : proven solution to the problemExamples : sample applications of the patternResulting context (force resolution)

the state of the system after pattern hasbeen applied

Alexandrian form (canonical form)

Rationale : explanation of steps or rulesin the pattern

Related patterns : static and dynamicrelationship

Known use : occurrence of the patternand its application within existingsystem

GoF formatPattern name and classificationIntent : what does pattern do / when the

solution worksAlso known as : other known names of pattern

(if any)Motivation : the design problem / how class and

object structures solve the problemApplicability : situations where pattern can be

appliedStructure :a graphical representation of classes

in the patternParticipants :the classes/objects participating

and their responsibilitiesCollaborations : of the participants to carry out

responsibilities

3

GoF format

Consequences : trade-offs, concernsImplementation : hints, techniquesSample code : code fragment showing possible

implementation

Known uses : patterns found in real systems

Related patterns : closely related patterns

Pattern templates[PATTERN-NAME]Author[YOUR-NAME] ([[email protected]]).Last updated on [TODAY'S-DATE]Context[PARAG-1][PARAG-2]Problem [ONE-ASPECT] [ANOTHER-ASPECT]ExamplesForces 1.[FORCE-1] 2.[FORCE-2]Design[PARAG-1][PARAG-2]An Implementation [SOME-CODE]ExamplesVariants [VARIANT] [ANOTHER-VARIANT]See Also [ANOTHER-REF]

http://hillside.net/patterns/Writing/Lea.html

•http://hillside.net/patterns/template.html•http://www.paterndepot.com/pages (Templates)

More pattern templates:More pattern templates:

IF you find yourself in CONTEXT for example EXAMPLES, with PROBLEM, entailing FORCES THEN for some REASONS, apply DESIGN FORM AND/OR RULE to construct SOLUTION leading to NEW CONTEXT and OTHER PATTERNS

http://g.oswego.edu/dl/pd-FAQ/pd-FAQ.html

What Is a Design Pattern

A design pattern is a descriptions of communicatingobjects and classes that are customized to solve ageneral design problem in a particular context

A pattern is made by four elements: name problem solution consequences

Name of Design Pattern

Describe a design problems and its solutions in aword or two

Used to talk about design pattern with our colleagues

Used in the documentation Increase our design vocabulary Have to be coherent and evocative

Problem

Describes when to apply the patterns

Explains the problem and its context

Sometimes include a list of conditions that must bemet before it makes sense to apply the pattern

Have to occurs over and over again in ourenvironment

Solution

Describes the elements that make up the design,their relationships, responsibilities andcollaborations

Does not describe a concrete design orimplementation

Has to be well proven in some projects

4

Consequences

Results and trade-offs of applying the pattern

Helpful for describe design decisions, forevaluating design alternatives

Benefits of applying a pattern (performance,time, size,…).

Impacts on a system’s flexibility,extensibilityor portability

Description of Design Pattern

Pattern name and classificationPattern name and classification contains the essence of pattern succinctly Become part of your design vocabulary

IntentIntent What does the pattern do ? What particular problem does it address ?


MotivationMotivation Illustrate a design problem and how the class and the

object structures solve the problem

ApplicabilityApplicability In which situations the pattern can be applied?

How can you recognize these situations?


StructureStructure Graphical representation of the classes and their

collaborations in the pattern

ParticipantsParticipants Class Objects Responsibilities

Description of Design PatternCollaborationsCollaborations How the participants collaborate to carry out their

responsibilities

ConsequencesConsequences How does the pattern support its objectives? What are the trade-offs and results of using the

pattern?


ImplementationImplementation : a sketch : a sketch

Sample CodeSample Code : a sketch : a sketch

Known UsesKnown Uses Examples of the pattern found in real systems

5


Related PatternsRelated Patterns What design patterns are closely related to this one?

What are the important differences?

By purpose and by scope

Creational patternsCreational patterns

Abstract the instantiation process Make a system independent to its realization Class Creational use inheritance to vary the instantiated

classes Object Creational delegate instantiation to an another object

Classification of DesignPattern


Structural patternsStructural patterns

Class Structural patterns concern the aggregationof classes to form largest structures

Object Structural pattern concern the aggregationof objects to form largest structures


Behavioral patternsBehavioral patterns

Concern with algorithms and assignment ofresponsibilities between objects

Describe the patterns of communication betweenclasses or objects

Behavioral class pattern use inheritance todistribute behavior between classes

Behavioral object pattern use object compositionto distribute behavior between classes

Classification of design patterns

InterpreterAdapterFactory Method

Visitor

Strategy

StateProxy

ObserverFlyweight

MementoFaçade

MediatorDecoratorSingleton

IteratorCompositePrototype

CommandBridgeBuilder

Chain ofResponsibility

AdapterAbstract Factory

Template Method

BehavioralBehavioralStructuralStructuralCreationalCreational

ObjectObject

ClassClasspurpose

Scope

Creational Patterns

Singleton Ensure a class only has one instance Provide a global point of access to it

Abstract Factory: Provide an interface for creating families of related

or dependent objects without specifying theirconcrete classes

6

Creational Pattern

Factory Method: Define an interface for creating an object but let

subclasses decide which class to instantiate Lets a class defer instantiation to subclasses

Prototype Specify the kinds of objects to create using a

prototypical instance Create new objects by copying this prototype

Creational Pattern

Builder: Separate the construction of a complex object from

its representation so that the same constructionprocess can create different representations

Structural Pattern

Composite Compose objects into tree structures to represent

part-whole hierarchies Lets clients treat individual objects and

compositions of objects uniformly

Decorator Attach additional responsibilities to an object

dynamically Provide a flexible alternative to subclassing for

extending functionality

Structural Pattern

Adapter Convert the interface of a class into another

interface clients expect Lets classes work together that couldn’t otherwise

because of incompatible interfaces

Bridge Decouple an abstraction from its implementation

so that the two can vary independently

Structural Pattern

Façade Provide a unified interface to a set of interfaces in

a subsystem Defines an higher-level interface that makes the

system easier to use

Flyweight Use sharing to support large numbers of fine-

grained objects efficiently

Structural Pattern

Proxy Provide a surrogate or placeholder for another object

to control access to it

7

Behavioral Pattern

Iterator Provide a way to access the elements of an

aggregate object without exposing itsrepresentation

Command Encapsulate a request as an object, thereby

letting you parameterize clients with differentrequests

Behavioral Pattern

Interpreter Given a language, define a representation for its

grammar along with an interpreter that uses therepresentation to interpret sentences in thelanguage

Mediator Define an object that encapsulate how a set of

objects interact Promotes loose coupling by keeping objects from

referring to each other explicitly Lets you vary their interaction independently

Behavioural patterns : The State

Motivation Objects often have internal states (MODE1,

MODE2,…)with related behaviour. Examples are lift,vending-machine, …

A Direct native implementation

Public class Context{

public static final int MODE1 = 0;public static final int MODE1 = 1;private int mode;. . . .

Public void request(){ if (mode == MODE1)

{code1}else if (mode == MODE2)

{Code2}}….} // Context

Problem with this implemetation

The program becomes rapidly intractable. Difficult to maintain : any change to the set of

modes requires a change to every method thatdepends on the mode.

Not efficient : each time we have to test for theappropriate mode.

Behavioral patterns : The State

The state pattern proposes explicit subclasses tocapture each mode.

The choice between different suclasses (i.e. the onecorrsponding to invoked mode) is achieved throughpolymorphism….and not by the programmer.

8


StateHandle()request()

State1

Handle()

State.handle()

Context

State2

Handle()

State

Code1 Code2


Benefits

Context1 : interface for clients; it maintains a Stateinstance to reflect the mode.

State : Abstract suoerclass of classes representingdifferent modes.

State1, 2… : each subclass of State implements thebehaviour of a specific mode.


Public class Context1{Private State state;

. . . .Public void request() { state.handle();}….} // Context1Abstract class State{ …..

public abstract void handle()} // State


class State1 extends State{

Private void handle() { code1 }} // State1

class State2 extends State{

Private void handle() { code2 }} // State1


Benefits Location of behavior : New states and transitions

can be added by defining new State subclasses. Code understandability and maintainability. State transitions are made explicit : State rather

than assignments


Example A common use of the state pattern is to reorganize

applications such as drawing tools. Drawing tools have different behaviour for

cooresponding modes (shape creation, shapeselection or text editing)

But responds to the same basic sets of events (e.g.mouse events).

9


mousePressed()keyPressed()

DrawingController mousePressed()keyPressed()

Tool

mousePressed()keyPressed()

TextToolmousePressed()

keyPressed()

SelectionToolmousePressed()

keyPressed()

CreationTool

currentTool

Behavioral patterns : The Template Method

It defines the schema of an algorithm in a superclassmethod, deferring details to subclasses.

Details (steps/parts) are redefined using subclasses. So, common part of an algorithm are factored out

into the superclass….No duplication.


Behavioral patterns : The TemplateMethod

Generic classTemplatemethod()

hookMethod1()hookMethod2()

ConcreteClass1


ConcreteClass2


….

hookMehtod1()

…

hookMethod2()

This super-class defines thetemplate method skeletonalgorithm, calling for one ormore hook methods…theycan abstract or have defaultcode.

This super-class defines thetemplate method skeletonalgorithm, calling for one ormore hook methods…theycan abstract or have defaultcode.

It implements one version ofthe hook methods

It implements one version ofthe hook methods

Behavioral patterns : The Template Method

Example

MSc and BSc students, with common attributesstudentId and numberPassed and a common methodaddMark(int m).

For MSc numberPassed is incremented only if m isgreater than 50. The same of BSc but the mark hasto be just more than 40.

Instead of duplicating, the pattern solution is toconsider addMark as a generic using a hook methodisPass (with different implementation in tworespective subclasses).


Public GeneralStudent (int id){ student id;}Abstract protected boolean isPass(int mark); /* Hook method */

Public void addMark(int m){if (isPass(m))}{numberPassed++};

}}

Class MScStudent extends GeneralStudent{ public MScStudent (int id){ super id:}

Protected boolean isPass(int m){ return (m >= 50) ;


Class BScStudent extends GeneralStudent{ public BScStudent (int id){ super id:}


10


Class MScStudent extends GeneralStudent{ public MScStudent (int id){ super id:}




GeneralStudent

addMark(m:int)isPass() : bool

MScStudent

isPass() : bool

BScStudent

isPass() : bool

If (isPass(m))

{numberPassed++}

IsPass implem. IsPass implem.

Behavioral patterns : The Visitor

It aims to separate the algorithms which operate overa data structure from the definition of that datastructure.

With that, algorithms and data may varyindependently.


Behavioral patterns : The Visitor<<interface>>

Element

Accept(Visitor v)

ElementA

Accept(Visitor v)

For all e instanceof Element

{if (children.contains(e))

{e.accept(v);}}

v.visit(this)

v.visit(this)v.visit(this)

ElementB

Accept(Visitor v)

Composite Element

Accept(Visitor v)

children*

The data structuresuperclass. It has anabstract accept method toprocess general visitors

The data structuresuperclass. It has anabstract accept method toprocess general visitors


Behavioral patterns : The Visitor<<interface>>

Visitor

Visit(ElementA e)Visit(ElementB e)Visit(Composite Element e)

ElementB

*

ConcreteVisitor

Visit(ElementA e)Visit(ElementB e)Visit(Composite Element e)



Expression

Variable

Name:string

Basic expression

Value : stringType: integer

Binary Expression

Operator : String

left

right

11


Example

Several functions (algorithms) are to beimplemented to extract properties of andlocally modify elements.1. Compute(ListofAllvariables).2. Rename(Varibales)…if s is the name of the

variable v (v.getName) then v.setName(String).

Behavioral patterns : The VisitorAbstract class Expression{public abstract void accept}

Class BinaryExpression extends Expression{private Expression left;Private expression right;Private string operator;

Public void accept(Visitor v){left.accept(v) right.accept(v); v.visit(this);}….}

Behavioral patterns : The VisitorClass BasicExpression extends Expression {private String value; private int type;

Public void accept(Visitor v) { v.visit(this);}}

Class Variable extends Expression {private String name;Public avoid setName(String nme) {name = nme;}

Public String getname() { return name; }

Public void accept(Visitor v) { v.visit(this);}

Behavioral patterns : The VisitorAbstract class Visitor {public abstract void visit (Variable v); public abstract void visit (BasicVariable be); public abstract void visit (BinaryExpression be);

private int type; Public void accept(Visitor v) { v.visit(this);}}

Behavioral patterns : The VisitorImport java.util.Vector;Public class GetUsesVisitor extends Visitor{ private Vector vars = new Vector();

Public void visit(Variable v){if (vars.contains(v.getName()) {} else { vars.add(v.getName());}} Public void visit(BasicExpression be) {} Public void visit(BinaryExpression be) {}}

Behavioral patterns : The VisitorImport java.util.Map;Import java.util.HashMap;

Public class RenameVisitor extends Visitor{private Map replacements = new HashMap(); }

Public void setReplacement(String old, String rep) { replacements.put(old,rep); }

Public void visit(Variable v) {String s = (String) replacements.get(v.getName());If (s != null){ v.setName(s);}}

Public void visit(BasicExpression be) {}Public void visit (BinaryExpression be) {}}

12

BibliographyFor the pattern catalogue:

Erich Gamma, Richard Helm,RalphJohnson,John Vlissides. Design Patterns:Elements of Reusable Object-OrientedSoftware. ADDISON-WESLEY 1995

For the pattern origin:Cristopher Alexander. The Timeless Way ofBuilding. Oxford Press 1979

James O.Coplien,Douglas C.Schmidt.PatternLanguages of Program Design. ADDISON-WESLEY 1995

Conclusions

At present, the software community is usingpattern largely for software architecture anddesignMore recently the software community isusing pattern also for software developmentprocesses and to organizationsSeveral object-oriented software designnotations/methods have added support forthe modeling and representation of designpatterns

introduction to design patterns why a design pattern · 6 creational pattern factory method: define...

Documents