Why a Design Pattern. History of Design Pattern. Properties

Transcription

1 Introduction to Design Patterns Nasreddine Aoumeur Why a Design Pattern Reusability: one of the basis for an efficient and actual SE discipline Helping new designers to have a more flexible and reusable design na@mcs.le.ac.uk 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. Pattern origins and history Kent Beck and Ward Cunningham, Textronix, OOPSLA'87 (used Alexander's "pattern" ideas for Smalltalk GUI design) Erich Gamma, Ph. D. thesis, James Coplien, Advanced C++ Idioms book, PLoP Conferences and books, 1994-present Buschmann, Meunier, Rohnert, Sommerland, Stal, Pattern -Oriented Software Architecture: A System of Patterns ( POSA book ) 1995: Group of Four alias E.Gamma, R.Helm,R.Johnson and J.Vlissides : Design Pattern:Elements of Reusable OO software Definition a fully realized form, original, or model accepted or proposed for imitation [dictionary]... describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice [Alexander] the abstraction from a concrete form which keeps recurring in specific non-arbitrary contexts [Riehle] both a thing and the instructions for making the thing [Coplien]...a literary format for capturing the wisdom and experience of expert designers, and communicating it to novices Properties Patterns do... provide common vocabulary provide shorthand for effectively communicating complex principles help document software architecture capture essential parts of a design in compact form show more than one solution describe software abstractions Patterns do not... provide an exact solution solve all design problems only apply for object-oriented design 1

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 Context a design situation giving rise to a design problem Problem a set of forces occuring in that context Solution a form or rule that can be applied to resolve these forces Example window place forces 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 analysis models) [Flower] organization patterns (structure of organizations/projects) process patterns (software process design) domain-specific patterns (ditribution, evolution, ) Alexandrian form (canonical form) Name : meaningful name Problem : the statement of the problem Context : a situation giving rise to a problem Forces : a description of relevant forces and constraints Solution : proven solution to the problem Examples : sample applications of the pattern Resulting context (force resolution) the state of the system after pattern has been applied Alexandrian form (canonical form) Rationale : explanation of steps or rules in the pattern Related patterns : static and dynamic relationship Known use : occurrence of the pattern and its application within existing system GoF format Pattern name and classification Intent : what does pattern do / when the solution works Also known as : other known names of pattern (if any) Motivation : the design problem / how class and object structures solve the problem Applicability : situations where pattern can be applied Structure :a graphical representation of classes in the pattern Participants :the classes/objects participating and their responsibilities Collaborations : of the participants to carry out responsibilities 2

3 GoF format Consequences : trade-offs, concerns Implementation : hints, techniques Sample code : code fragment showing possible implementation Known uses : patterns found in real systems Related patterns : closely related patterns [PATTERN-NAME] Author [YOUR-NAME] ([YOU@YOUR.ADDR]). Last updated on [TODAY'S-DATE] Context [PARAG-1] IF [PARAG-2] Problem [ONE-ASPECT] [ANOTHER-ASPECT] Examples Forces 1.[FORCE-1] 2.[FORCE-2] Design [PARAG-1] [PARAG-2] An Implementation [SOME-CODE] Examples Variants [VARIANT] [ANOTHER-VARIANT] See Also [ANOTHER-REF] Pattern templates 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 More pattern templates: (Templates) 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 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 Solution 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 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 3

4 Consequences Results and trade-offs of applying the pattern Helpful for describe design decisions, for evaluating design alternatives Benefits of applying a pattern (performance, time, size, ). Impacts on a system s flexibility,extensibility or portability Description of Design Pattern Pattern name and classification contains the essence of pattern succinctly Become part of your design vocabulary Intent What does the pattern do? What particular problem does it address? Description of Design Pattern Motivation Illustrate a design problem and how the class and the object structures solve the problem Applicability In which situations the pattern can be applied? How can you recognize these situations? Description of Design Pattern Structure Graphical representation of the classes and their collaborations in the pattern Participants Class Objects Responsibilities Description of Design Pattern Collaborations How the participants collaborate to carry out their responsibilities Consequences How does the pattern support its objectives? What are the trade-offs and results of using the pattern? Description of Design Pattern Implementation : a sketch Sample Code : a sketch Known Uses Examples of the pattern found in real systems 4

5 Description of Design Pattern Related Patterns What design patterns are closely related to this one? What are the important differences? Classification of Design Pattern 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 Structural patterns Classification of Design Pattern Behavioral 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 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 S c o p e Class Object Creational Factory Method Abstract Factory Builder Prototype Singleton purpose Structural Adapter Adapter Bridge Composite Decorator Façade Flyweight Proxy Behavioral Interpreter Template Method Chain of Responsibility Command Iterator Mediator Memento Observer State Strategy Visitor 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 their concrete classes 5

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 construction process 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 finegrained objects efficiently Structural Pattern Proxy Provide a surrogate or placeholder for another object to control access to it 6

7 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 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 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 that depends on the mode. Not efficient : each time we have to test for the appropriate mode. The state pattern proposes explicit subclasses to capture each mode. The choice between different suclasses (i.e. the one corrsponding to invoked mode) is achieved through polymorphism.and not by the programmer. 7

8 Context request() State State Handle() State.handle() State1 State2 Benefits Context1 : interface for clients; it maintains a State instance to reflect the mode. State : Abstract suoerclass of classes representing different modes. State1, 2 : each subclass of State implements the behaviour of a specific mode. Handle() Code1 Handle() Code2 Public class Context1 { Private State state;.... Public void request() { state.handle();}. } // Context1 Abstract 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, shape selection or text editing) But responds to the same basic sets of events (e.g. mouse events). 8

9 DrawingController mousepressed() keypressed() currenttool Tool mousepressed() keypressed() Behavioral patterns : The Template Method It defines the schema of an algorithm in a superclass method, 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. CreationTool mousepressed() keypressed() SelectionTool mousepressed() keypressed() TextTool mousepressed() keypressed() Behavioral patterns : The Template Method This super-class defines the Generic class Templatemethod() hookmethod1() hookmethod2() ConcreteClass1 hookmethod1() hookmethod2() This super-class defines the template method method skeleton algorithm, calling calling for for one one or or more more hook hook methods they can can abstract or or have have default default code. code.. hookmehtod1() hookmethod2() ConcreteClass2 hookmethod1() hookmethod2() It It implements one one version version of of the the hook hook methods Behavioral patterns : The Template Method Example MSc and BSc students, with common attributes studentid and numberpassed and a common method addmark(int m). For MSc numberpassed is incremented only if m is greater than 50. The same of BSc but the mark has to be just more than 40. Instead of duplicating, the pattern solution is to consider addmark as a generic using a hook method ispass (with different implementation in two respective subclasses). Behavioral patterns : The Template Method 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:} Behavioral patterns : The Template Method Class BScStudent extends GeneralStudent { public BScStudent (int id) { super id:} Protected boolean ispass(int m) { return (m >= 40) ; Protected boolean ispass(int m) { return (m >= 50) ; 9

10 Behavioral patterns : The Template Method Behavioral patterns : The Template Method Class MScStudent extends GeneralStudent { public MScStudent (int id) { super id:} GeneralStudent addmark(m:int) ispass() : bool If (ispass(m)) {numberpassed++} Protected boolean ispass(int m) { return (m >= 50) ; MScStudent ispass() : bool IsPass implem. BScStudent ispass() : bool IsPass implem. <<interface>> Element The The data structure superclass. It It has has an an abstract accept method to to process general visitors It aims to separate the algorithms which operate over a data structure from the definition of that data structure. With that, algorithms and data may vary independently. ElementA Accept(Visitor v) * children ElementB Composite Element Accept(Visitor v) Accept(Visitor v) Accept(Visitor v) v.visit(this) For all e instanceof Element {if (children.contains(e)) {e.accept(v);}} v.visit(this) <<interface>> Visitor * Visit(ElementA e) Visit(ElementB e) Visit(Composite Element e) Expression left right Concrete Visitor Variable Name:string Basic expression Value : string Type: integer Binary Expression Operator : String Visit(ElementA e) Visit(ElementB e) Visit(Composite Element e) 10

11 Example Abstract class Expression {public abstract void accept} Several functions (algorithms) are to be implemented to extract properties of and locally modify elements. 1. Compute(ListofAllvariables). 2. Rename(Varibales) if s is the name of the variable v (v.getname) then v.setname(string). 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); }. } Class 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; } Abstract 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);} } Public void accept(visitor v) { v.visit(this);} Import 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) {} } Import 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) {} } 11

12 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 James O.Coplien,Douglas C.Schmidt.Pattern Languages of Program Design. ADDISON- WESLEY 1995 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 to organizations Several object-oriented software design notations/methods have added support for the modeling and representation of design patterns 12