DESIGN PATTERNS

NOTES

Design Patterns:

Elements of Reusable Object – Oriented Software

Design Pattern Introduction: why a design pattern?

History of design pattern

What is a design pattern

How we describe design pattern

Classification of desing pattern

Examples of design pattern

Conclusions

Bibliography

Why a Design Pattern

Reusability:one of Wasserman’s rules(1996)for an efficient and actual SE discipline

Helping new designers to have a more flexible and reusable design

Improving the documentation and maintenance of existing system by furnishing an explicit specification of class and object interactions and their intent

History of Design Pattern

1979:Christopher Alexander,architect, “The Timeless Way of Building”,Oxford Press

1987:OOPSLA (Object Oriented Programming System),Orlando, presentation of design pattern to the community OO by Ward Cunningham and Kent Beck

1995:Group of Four alias E.Gamma, R.Helm,R.Johnson and J.Vlissides : “Design Pattern:Elements of Reusable OO software”

What Is a Design PatternA design pattern is a descriptions of communicating

objects and classes that are customized to solve a general design problem in a particular context

A pattern is made by four elements:nameproblemsolutionconsequences

Name of Design Pattern

Describe a design problems and its solutions in a word 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 be met before it makes sense to apply the pattern

Have to occurs over and over again in our environment

Solution

Describes the elements that make up the design, their relationships, responsibilities and collaborations

Does not describe a concrete design or implementation

Has to be well proven in some projects

Consequences

Results and trade-offs of applying the pattern

Helpful for describe design decisions, for evaluating design alternatives

Benefits of applying a pattern

Impacts on a system’s flexibility,extensibility or portability

Description of Design Pattern Pattern name and classificationPattern name and classification

contains the essence of pattern succinctly

Become part of your design vocabulary

IntentIntentWhat does the pattern do ?

What particular problem does it address ?

Description of Design Pattern

MotivationMotivationIllustrate a design problem and how the class and the object structures solve the

problem

ApplicabilityApplicabilityIn which situations the pattern can be applied?

How can you recognize these situations?

Description of Design Pattern

StructureStructureGraphical representation of the classes and their collaborations in the

pattern

ParticipantsParticipantsClass

Objects

Responsibilities

Description of Design PatternCollaborationsCollaborations

How the participants collaborate to carry out their responsibilities

ConsequencesConsequencesHow does the pattern support its objectives?

What are the trade-offs and results of using the pattern?

Description of Design Pattern

ImplementationImplementation

Sample CodeSample Code

Known UsesKnown UsesExamples of the pattern found in real systems

Description of Design Pattern

Related PatternsRelated PatternsWhat 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 Design Pattern

Classification of Design Pattern Structural patternsStructural patterns

Class Structural patterns concern the aggregation of classes to form largest structures

Object Structural pattern concern the aggregation of objects to form largest structures

Classification of Design Pattern Behavioral patternsBehavioral patterns

Concern with algorithms and assignment of responsibilities between objects

Describe the patterns of communication between classes or objects

Behavioral class pattern use inheritance to distribute behavior between classes

Behavioral object pattern use object composition to distribute behavior between classes

Classification of design patterns ( a view)

InterpreterAdapterFactory Method

Visitor

Strategy

StateProxy

ObserverFlyweight

MementoFaçade

MediatorDecoratorSingleton

IteratorCompositePrototype

CommandBridgeBuilder

Chain of Responsibility

AdapterAbstract Factory

Template Method

BehavioralBehavioralStructuralStructuralCreationalCreational

ObjectObject

ClassClass

purpose

Scope

Creational Pattern

SingletonEnsure 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 their concrete classes

Creational PatternFactory 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 construction process can create different representations

Structural PatternComposite

Compose objects into tree structures to represent part-whole hierarchies

Lets clients treat individual objects and compositions of objects uniformly

DecoratorAttach 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 expectLets 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 PatternFaç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

FlyweightUse sharing to support large numbers of fine-grained objects efficiently

Structural Pattern

ProxyProvide a surrogate or placeholder for another object to control access to it

Behavioral PatternIterator

Provide a way to access the elements of an aggregate object without exposing its representation

CommandEncapsulate a request as an object, thereby letting you parameterize clients

with different requests

Behavioral PatternInterpreter

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language

MediatorDefine 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

Behavioral PatternMemento

Capture and externalize an object’s internal state

ObserverDefine a one-to-many dependency between objects so when one of them

change state all its dependents are updated automatically

Behavioral PatternState

Allow an object to alter its behavior when its internal state changes

The object will appear to change its class

VisitorRepresent an operation to be performed on the elements of an object

structure

Lets you define a new operation without changing the classes of the elements on which operates

Behavioral PatternStrategy

Define a family of algorithms

Encapsulate each one

Make them interchangeable

Lets the algorithms vary independently from clients that use it

Chain of responsibilitiesAvoid coupling the sender of a request to its receiver by giving more then one

object a chance to handle the request

Chain the receiving objects and pass the request along the chain until an object handles it

Singleton PatternMotivation

we need to have exactly only one instance for a class (ex. Printer spooler)

Make the class itself responsible for keeping track of its sole instance

The class provide a way to access the instance

ApplicabilityThere must be only one instance of a class accessible from a well-known

point

Singleton PatternStructure

Singleton

Static Instance()SingletonOperation()GetSingletonData()

Static uniqueInstanceSingletonData

Return uniqueInstance

Singleton PatternParticipants

Singleton class

CollaborationsAccess only through Singleton’s instance operation

ConsequencesControlled access to sole instance

Permits refinement of operation and representation

More flexible than class operations

Example of Singleton use“Lotteria Algebrica”

We had to have only one instance for class Director. We simply solve our problem using Singleton PatternDirector

Static Instance()Given(n_ticket:int):void

Error():void

Static UniqueInstance

Decorator PatternMotivation

Add responsibilities to individual object not to an entire class

conforming the interface of the component decorated

Decorator PatternStructure Component

Operation()

ConcreteComponent

Operation()

Decorator

Operation()

ConcreteDecoratorAOperation()AddedState

ConcreteDecoratorBOperation()

Addedbehavior

Decorator PatternParticipants

ComponentDefine the interface for objects that can have responsibilities

added to them dinamically

Concrete ComponentDefines an object to which additional responsibilities can be

attached

Decorator Mantains a reference to a Component object and defines an

interface that conforms to Component’s interface

ConcreteDecoratorAdded responsibilities to the component

Decorator PatternConsequences

More flexibility than static inheritance

Avoids feature-laden classes high up in the hierarchy

A decorator and its component are not identical

Lots of little objects

Example of Decorator

MotivationIf you have a TextView object that displays text in a Window

TextView has no scroll bars by default

TextView has no bord by default …

Example of DecoratorStructure

aBorderDecorator

component

aScrollDecorator

component

aTextView

Example of DecoratorStructureVisualComponent

Draw()

TextView

Draw()

Decorator

Draw()

ScrollDecorator BorderDecorator

Draw()ScrollTo()

ScrollPosition

Draw()DrawBorder()

BorderWidth

Iterator PatternAlso know as

Cursor

MotivationProvide more way to access to the elements of an aggregate

List

Count()Append(Element)Remove(Element)

…

ListIterator

First()Next()

IsDone()CurrentItem

Index

Iterator Pattern

ApplicabilityAccess an aggregate object’s contents

Support multiple traversals of aggregate objects

Provide an uniform interface

Iterator PatternStructureAggregate

CreateIterator()

ConcreteAggregate

CreateIterator()

Iterator

First()Next()

IsDone()CurrentItem()

ConcreteIterator

Return newConcreteIterator(This)

Client

Iterator PatternParticipants

IteratorDefines interfaces for accessing elements

ConcreteIteratorImplements the Iterator interface

Keeps track of the current position in the traversal of the aggregate

AggregateDefines an interface for creating an Iterator object

Concrete AggregateImplements the Iterator creation interface

Return an instance of ConcreteIterator

Iterator PatternConsequences

Simplify the Aggregate interface

More that one traversal can be pending on an aggregate

Variations in the traversal of an aggregate

Patterns and Frameworks

Design patterns are more abstract than frameworks

Design patterns are smaller architectural elements than frameworks

Design patterns are less specialized than frameworks

Framework is executable software, design pattern represent knowledge about software

Frameworks are the physical realization of one or more software pattern solutions,pattern are instructions for how to implement those solutions

Set of cooperating classes that make up reusable design for a specific class of software. Provides

architectural guidance by partitioning the design into abstract classes and defining their responsibilities

and collaborations.A developer customizes a framework to a particular application by subclassing and composing instances

of framework classes.

ConclusionsAt present, the software community is using pattern

largely for software architecture and design

More recently the software community is using pattern also for software development processes and o organizations

Several object-oriented software design notations/methods have added support for the modeling and representation of design patterns

BibliographyFor the pattern catalogue:

Erich Gamma, Richard Helm,Ralph Johnson,John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. ADDISON-WESLEY 1995

For the pattern origin:

Cristopher Alexander. The Timeless Way of Building. Oxford Press 1979

For “Night Patterns”:

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

More InformationHere you can find some example in Italian of design patterns.

http://www.ugolandini.net/PatternsHome.htmlHere you can find some general information about patterns

http://www.mokabyte.it/1998/10/pattern.htm

http://www.c2.comA complete Web site about pattern

http://www.enteract.com/~bradapp/docs/patterns-intro.html