design patterns 1 design patterns: elements of reusable object – oriented software course of...
Post on 22-Dec-2015
228 views
TRANSCRIPT
Design Patterns1
Design Patterns:
Elements of Reusable Object – Oriented Software
Course of Software
Engineering II
Serena Fabbri
Design Patterns2
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
Design Patterns3
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
Design Patterns4
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”
Design Patterns5
What Is a Design Pattern A 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: name problem solution consequences
Design Patterns6
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
Design Patterns7
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
Design Patterns8
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
Design Patterns9
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
Design Patterns10
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 ?
Design Patterns11
Description of Design Pattern
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?
Design Patterns12
Description of Design Pattern
StructureStructure Graphical representation of the classes and their collaborations in the pattern
ParticipantsParticipants Class Objects Responsibilities
Design Patterns13
Description of Design Pattern
CollaborationsCollaborations 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?
Design Patterns14
Description of Design Pattern
ImplementationImplementation
Sample CodeSample Code
Known UsesKnown Uses Examples of the pattern found in real systems
Design Patterns15
Description of Design Pattern
Related PatternsRelated Patterns What design patterns are closely related to this one?
What are the important differences?
Design Patterns16
By purpose and by scope
Creational 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
Design Patterns17
Classification of Design Pattern Structural 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
Design Patterns18
Classification of Design Pattern Behavioral 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
Design Patterns19
Classification of design patterns ( a view)
CreationalCreational StructuralStructural BehavioralBehavioral
Factory Method Adapter Interpreter
Template Method
Abstract Factory Adapter Chain of Responsibility
Builder Bridge Command
Prototype Composite Iterator
Singleton Decorator Mediator
Façade Memento
Flyweight Observer
Proxy State
Strategy
Visitor
ClassClass
ObjectObject
purpose
Scope
Design Patterns20
Creational Pattern
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 their concrete classes
Design Patterns21
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
Design Patterns22
Creational Pattern
Builder: Separate the construction of a complex object from its representation so that the same construction process can create different representations
Design Patterns23
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
Design Patterns24
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
Design Patterns25
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
Design Patterns26
Structural Pattern
Proxy Provide a surrogate or placeholder for another object to control access to it
Design Patterns27
Behavioral Pattern Iterator
Provide a way to access the elements of an aggregate object without exposing its representation
Command Encapsulate a request as an object, thereby letting you parameterize clients with different requests
Design Patterns28
Behavioral Pattern Interpreter
Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language
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
Design Patterns29
Behavioral Pattern Memento
Capture and externalize an object’s internal state
Observer Define a one-to-many dependency between objects so when one of them change state all its dependents are updated automatically
Design Patterns30
Behavioral Pattern State
Allow an object to alter its behavior when its internal state changes
The object will appear to change its class
Visitor Represent 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
Design Patterns31
Behavioral Pattern Strategy
Define a family of algorithms Encapsulate each one Make them interchangeable Lets the algorithms vary independently from clients that use it
Chain of responsibilities Avoid 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
Design Patterns32
Singleton Pattern Motivation
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
Applicability There must be only one instance of a class accessible from a well-known point
Design Patterns33
Singleton Pattern Structure
Singleton
Static Instance()SingletonOperation()GetSingletonData()
Static uniqueInstanceSingletonData
Return uniqueInstance
Design Patterns34
Singleton Pattern Participants
Singleton class Collaborations
Access only through Singleton’s instance operation
Consequences Controlled access to sole instance Permits refinement of operation and representation
More flexible than class operations
Design Patterns35
Example of Singleton use
“Lotteria Algebrica” We had to have only one instance for class Director. We simply solve our problem using Singleton Pattern
Director
Static Instance()Given(n_ticket:int):void
Error():void
Static UniqueInstance
Design Patterns36
Decorator Pattern
Motivation Add responsibilities to individual object not to an entire class
conforming the interface of the component decorated
Design Patterns37
Decorator Pattern Structure
Component
Operation()
ConcreteComponent
Operation()
Decorator
Operation()
ConcreteDecoratorAOperation()AddedState
ConcreteDecoratorBOperation()
Addedbehavior
Design Patterns38
Decorator Pattern Participants
Component Define the interface for objects that can have responsibilities added to them dinamically
Concrete Component Defines 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
ConcreteDecorator Added responsibilities to the component
Design Patterns39
Decorator Pattern Consequences
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
Design Patterns40
Example of Decorator
Motivation If you have a TextView object that
displays text in a Window TextView has no scroll bars by default TextView has no bord by default …
Design Patterns41
Example of Decorator Structure
aBorderDecorator
component
aScrollDecorator
component
aTextView
Design Patterns42
Example of Decorator Structure
VisualComponent
Draw()
TextView
Draw()
Decorator
Draw()
ScrollDecorator BorderDecorator
Draw()ScrollTo()
ScrollPosition
Draw()DrawBorder()
BorderWidth
Design Patterns43
Iterator Pattern Also know as
Cursor Motivation
Provide more way to access to the elements of an aggregate
List
Count()Append(Element)Remove(Element)
…
ListIterator
First()Next()
IsDone()CurrentItem
Index
Design Patterns44
Iterator Pattern
Applicability Access an aggregate object’s contents Support multiple traversals of aggregate objects
Provide an uniform interface
Design Patterns45
Iterator Pattern Structure
Aggregate
CreateIterator()
ConcreteAggregate
CreateIterator()
Iterator
First()Next()
IsDone()CurrentItem()
ConcreteIterator
Return newConcreteIterator(This)
Client
Design Patterns46
Iterator Pattern Participants
Iterator Defines interfaces for accessing elements
ConcreteIterator Implements the Iterator interface Keeps track of the current position in the traversal of the aggregate
Aggregate Defines an interface for creating an Iterator object
Concrete Aggregate Implements the Iterator creation interface Return an instance of ConcreteIterator
Design Patterns47
Iterator Pattern Consequences
Simplify the Aggregate interface More that one traversal can be pending on an aggregate
Variations in the traversal of an aggregate
Design Patterns48
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.
Design Patterns49
Conclusions At 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
Design Patterns50
Night Patterns
The coffee mug etched black insideHaunts the worn gray keys. The computer screen amused pearlwhite lights
the developer’s handsAnd his night still life:pencils and books,scattered page of code circled and crossed with notes.Outside, along the river, white headlights flow,Red lights retreat.
Design Patterns51
Night Patterns
Inside the agile black box it waits- the Conjuring That lifts alive vined parts,Veins flowing in forces he imaginesBy circles and crosses, in dozing spells,In whitened warmth upon noon earth, In peach trees by the wall-It waits to pulse the pagesToward life,the patterns of night, to bringThe quality,singing soft and hangign low.RICHARD GABRIEL
Design Patterns52
Bibliography
For 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
Design Patterns53
More Information
Here you can find some example in Italian of design patterns.
http://www.ugolandini.net/PatternsHome.html
Here 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