1. Design Patterns 1 Design Patterns: Elements of Reusable Object – Oriented Software Course of Software Engineering II Serena Fabbri

2. Design Patterns 2 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

3. Design Patterns 3 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

4. Design Patterns 4 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”

5. Design Patterns 5 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 name  problem problem  solution solution  consequences consequences

6. Design Patterns 6 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

7. Design Patterns 7 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

8. Design Patterns 8 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

9. Design Patterns 9 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

10. Design Patterns 10 Description of Design Pattern Pattern name and classification Pattern name and classification contains the essence of pattern succinctly Become part of your design vocabulary Intent Intent What does the pattern do ? What particular problem does it address ?

11. Design Patterns 11 Description of Design Pattern Motivation Illustrate a design problem and how the class and the object structures solve the problem Applicability Applicability In which situations the pattern can be applied? How can you recognize these situations ?

12. Design Patterns 12 Description of Design Pattern Structure Structure Graphical representation of the classes and their collaborations in the pattern Participants Participants Class Objects Responsibilities

13. Design Patterns 13 Description of Design Pattern Collaborations Collaborations How the participants collaborate to carry out their responsibilities Consequences Consequences How does the pattern support its objectives? What are the trade-offs and results of using the pattern?

14. Design Patterns 14 Description of Design Pattern Implementation Implementation Sample Code Sample Code Known Uses Known Uses Examples of the pattern found in real systems

15. Design Patterns 15 Description of Design Pattern Related Patterns Related Patterns What design patterns are closely related to this one? What are the important differences ?

16. Design Patterns 16 By purpose and by scope Creational patterns Creational patterns Creational patterns 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

17. Design Patterns 17 Classification of Design Pattern Structural patterns Structural patterns 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

18. Design Patterns 18 Classification of Design Pattern Behavioral patterns Behavioral patterns 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

19. Design Patterns 19 Classification of design patterns ( a view) CreationalStructuralBehavioral Factory MethodAdapterInterpreter Template Method Abstract FactoryAdapterChain of Responsibility BuilderBridgeCommand PrototypeCompositeIterator SingletonDecoratorMediator FaçadeMemento FlyweightObserver ProxyState Strategy VisitorClassObject purpose Scope

20. Design Patterns 20 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

21. Design Patterns 21 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

22. Design Patterns 22 Creational Pattern Builder: Separate the construction of a complex object from its representation so that the same construction process can create different representations

23. Design Patterns 23 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

24. Design Patterns 24 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

25. Design Patterns 25 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

26. Design Patterns 26 Structural Pattern Proxy Provide a surrogate or placeholder for another object to control access to it

27. Design Patterns 27 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

28. Design Patterns 28 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

29. Design Patterns 29 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

30. Design Patterns 30 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

31. Design Patterns 31 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

32. Design Patterns 32 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

33. Design Patterns 33 Singleton Pattern Structure Singleton Static Instance() SingletonOperation() GetSingletonData() Static uniqueInstance SingletonData Return uniqueInstance

34. Design Patterns 34 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

35. Design Patterns 35 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

36. Design Patterns 36 Decorator Pattern Motivation Add responsibilities to individual object not to an entire class conforming the interface of the component decorated

37. Design Patterns 37 Decorator Pattern Structure Component Operation() ConcreteComponent Operation() Decorator Operation() ConcreteDecoratorA Operation() AddedState ConcreteDecoratorB Operation() Addedbehavior

38. Design Patterns 38 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

39. Design Patterns 39 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

40. Design Patterns 40 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 …

41. Design Patterns 41 Example of Decorator Structure aBorderDecorator component aScrollDecorator component aTextView

42. Design Patterns 42 Example of Decorator Structure VisualComponent Draw() TextView Draw() Decorator Draw() ScrollDecoratorBorderDecorator Draw() ScrollTo() ScrollPosition Draw() DrawBorder() BorderWidth

43. Design Patterns 43 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

44. Design Patterns 44 Iterator Pattern Applicability Access an aggregate object’s contents Support multiple traversals of aggregate objects Provide an uniform interface

45. Design Patterns 45 Iterator Pattern Structure Aggregate CreateIterator() ConcreteAggregate CreateIterator() Iterator First() Next() IsDone() CurrentItem() ConcreteIterator Return new ConcreteIterator(This) Client

46. Design Patterns 46 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

47. Design Patterns 47 Iterator Pattern Consequences Simplify the Aggregate interface More that one traversal can be pending on an aggregate Variations in the traversal of an aggregate

48. Design Patterns 48 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.

49. Design Patterns 49 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

50. Design Patterns 50 Night Patterns The coffee mug etched black inside Haunts the worn gray keys. The computer screen amused pearlwhite lights the developer’s hands And 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.

51. Design Patterns 51 Night Patterns Inside the agile black box it waits- the Conjuring That lifts alive vined parts, Veins flowing in forces he imagines By circles and crosses, in dozing spells, In whitened warmth upon noon earth, In peach trees by the wall- It waits to pulse the pages Toward life,the patterns of night, to bring The quality,singing soft and hangign low. RICHARD GABRIEL

52. Design Patterns 52 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

53. Design Patterns 53 More Information Here you can find some example in Italian of design patterns. http://www.ugolandini.net/PatternsHome.ht ml http://www.ugolandini.net/PatternsHome.ht ml Here you can find some general information about patterns http://www.mokabyte.it/1998/10/pattern.ht m http://www.mokabyte.it/1998/10/pattern.ht m http://www.c2.com A complete Web site about pattern http://www.enteract.com/~bradapp/docs/pat terns-intro.html http://www.enteract.com/~bradapp/docs/pat terns-intro.html