A reusable design concept

Transcription

1 References: Xiaoping Jia, Object-Oriented Software Development Using Java;Douglas C.Schmidt, Design Pattern Case Studies with C++;Bruce E.Wampler,The Essence of Object-Oriented Programming with Java and UML;Design Patterns by Gamma et al.; Cay Horstmann, Object-Oriented Design & Patterns; 1 A reusable design concept Design patterns are reusable solutions to recurring design problems that emerge during software development Design patterns make design easier by offering solutions to common design problems Reuse brings benefits of OOP to OOD reusing design others have used successfully in the past 2 1

2 Abstract solution Design patterns are an abstract solution to a general design problem 3 Design Patterns Capture Expertise Design patterns capture expertise and facilitate its dissemination study of design patterns can shorten the path from new programmer to experienced designer design patterns offer a convenient way of documenting and transferring design skills 4 2

3 Patterns: a common vocabulary Design patterns define a common vocabulary for discussing design and architecture shared vocabulary is necessary for communication; words in vocabulary should be appropriately abstract for ideas to be communicated thinking in terms of low-level artifacts such as classes, interfaces and interactions may inhibit design and architecture ideas 5 And Finally... Design patterns demonstrate good design principles exhibit principles of encapsulation, cohesion and abstraction Design patterns are common in class libraries such as the Java API 6 3

4 Patterns are NOT: A solution to a specific problem The magical answer to all problems A substitute for design work (you still must do that yourself) Concrete classes, libraries or pre-made solutions 7 History of Design Patterns Originated in field of architecture with book by Christopher Alexander books about recurring themes in design of buildings and spaces A Pattern Language: Towns,Buildings, Construction, 1977 The Timeless Way of Building,

5 History of Design Patterns Christopher Alexander: Each pattern 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. 9 Alexander s Elements for Design Patterns Alexander described every pattern as having a short name a brief description of the context a long description of the problem a prescription for a solution The OO community adapted these elements for software design patterns 10 5

6 History of Design Patterns First industry conference on design patterns held in 1994 Pattern Languages of Program Design (PLoP) Gang of Four (GofF) book on design patterns published: Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson & John Vlissides 11 Design Patterns - GofF Defined a set of reusable software design patterns Three categories Creational : deal with process of creation Structural : deal with static composition and structure of classes and objects Behavioral : deal with dynamic interaction among classes and objects 12 6

7 Design Patterns - GofF Each pattern is described in the following terms: Pattern name Category : creational, structural or behavioral Problem: description of problem addressed Applicability : where pattern can be applied Structure : diagram that describes participants in the pattern & relationships among them Participants : list of classes and/or objects that participate in the pattern 13 Pattern Name Pattern name provides the common vocabulary for describing design elements to others A simple name reduces an entire problem, solution and consequences to a single term 14 7

8 Problem Each design pattern solves some discrete set of design problems and describes the set of problems that it is designed to solve 15 Solution The solution describes how the pattern will solve the problem It identifies the architecturally significant objects in the solution responsibilities and relationships that significant objects share The solution is a general one so pattern can apply to many different specific problems 16 8

9 Some Common Design Patterns Observer Adapter Iterator Singleton Strategy Factory Decorator 17 Observer Pattern Observer is an object that is interested in the model s state changes Notification is done through observers A subject can have any number of dependent observers that are notified when the subject undergoes a state change. The subject does not need to know who its observers are 18 9

10 Observer Pattern Category : Behavioral Name: Observer (Publish-Subscribe) Problem: Define a 1 to many relationship so when one object (observed) changes state, all dependents (observers) are notified, and they update themselves. Because coupling is loose, an observer can change or be added without affecting the observed or other observers. Observed object can also be modified independently of the observers. 19 Observer Pattern : Structure Subject +addobserver(obs:observer) +deleteobserver(obs:observer) +notify() observers for all o in observers {o.update()} Observer +update() ConcreteSubject +getstate() +setstate() subject ConcreteObserver +update() 20 10

11 Observer: Applicability Example of the Observer Pattern you see often: Show 3 Explorer windows with 3 different views Delete a file in one of the windows Show Spreadsheet Data is the model Charts are the view 21 Java Example of Observer Java supports Observer with the class java.util.observable and an interface java.util.observer Classes that want to change the state of the subject implement the interface and register with the subject to receive notification when the state changes 22 11

12 UML Diagram for java s Observer/Observable Observable -observers:vector -changed:boolean +addobserver(observer o) +deleteobserver(observer o) #setchanged() +notifyobservers() +notifyobservers(object arg) <<interface>> Observer update(observable obs, Object obj) Observer interface corresponds to Observer class in the Pattern Observable corresponds to the Subject class in the Pattern public voidnotifyobservers(object arg) { if (!changed) return; changed = false; for each observer o in vector observers o.update(this,arg) } 23 Model/View/Controller The Observer pattern is an integral part of the Model-View-Controller design pattern. MVC separates the three elements of a user interface application: model or data portion of the application view or display of the data controlling portion of the application control portion responsible for updating data from user input or other events updating the views when data changes is handled by the Observer design pattern (a sub-pattern of MVC) 24 12

13 Model/View/Controller MVC architecture many different views of the same data model holds information in some data structure views draw visible parts of the data in a format specific to the view a table view displays numbers in a table a graph view displays same data in a pie chart each view has a controller -- object that processes user interaction 25 Model/View/Controller Problem: separates key elements of user interface such that the application is more maintainable and extendable. A change to one element is not likely to affect other elements. New elements can be added without causing significant changes to existing elements

14 Model/View/Controller Solution: built on Observer design pattern Model is the observable object or subject Views are the observers MVC design pattern is Observer design pattern with a control component controller is the portion responsible for updating the model controller may physically be part of the view or a separate component 27 MVC Structure Model Update Change View Change Controller 28 14

15 MVC Scenario Controller tells model to insert text that user typed model notifies all views of change in the model all views repaint themselves each view asks model for the current text when repainting 29 MVC Model: Represents system with the business logic View: Displays the model Controllers: Handle user interaction and sends correct messages to the model and/or view [Mercer] 30 15

16 Model The Model's responsibilities Provide access to the state of the system Provide access to the system's functionality Can notify the view(s) that its state has changed [Mercer] 31 Controller The controller's responsibilities Accept user input Button clicks, key presses, mouse movements, slider bar changes Send messages to the model, which may in turn notify its observers Send appropriate messages to the view In Java, listeners are controllers [Mercer] 32 16

17 View The view's responsibilities Displaying the state of the model to the user At some point, the model (a.k.a. the observable) must register the views (a.k.a. observers) so the model can notify the observers that its state has changed [Mercer] 33 MVC minimizes coupling Model knows nothing about views -- except that they need to be notified of changes Views know nothing of controllers Easy to add more views to a model Easy to change controller for a view 34 17

18 Adapter Pattern The Adapter pattern solves the problem of incompatibility by transforming an incompatible interface into one that is needed. The incompatible object is wrapped inside a compatible adapter object. The adapter object holds onto an instance of the object and exposes the object through the interface that fits into your program. 35 Adapter Pattern Category : Structural Pattern name: Adapter (a.k.a. Wrapper) Problem: How to reuse incompatible objects 36 18

19 Adapter Pattern Solution: Provide an adapter class that holds a reference to the service available and implements the interface the client expects Consequences: Makes incompatible objects compatible; results in extra classes if you use inheritance or need to handle each subclass differently 37 UML for Adapter Design Pattern Client interfaceclientexpects methodclientexpects() interfaceavailable methodavailable() Adapter -adaptee:interfaceavailable methodclientexpects() ServiceAvailable public void methodclientexpects() { adaptee.methodavailable(); } 38 19

20 Adapter Example When using inheritance and substitutability, an object will not be able to plug in to your program unless it is part of the substitutability hierarchy Solution which does not use the Adapter pattern: edit the class you want to use so it inherits from the right class requires that you have the source code not practical to rewrite every class you might need to include in the hierarchy 39 Implementing an Adapter PsychiatristObject MoodyObject examine(obj:moodyobject) querymood() getmood():string HappyObject getmood():string CarefreeObject getmood():string SadObject getmood():string [Sintes example] Only MoodyObjects can be examined by Psychiatrist objects 40 20

21 Consider the Pet hierarchy Pet speak():string Pet speak():string Pet speak():string Pet speak():string Pets sometimes go to psychiatrists, but the MoodyObject hierarchy does not provide for a Pet object to be examined. So we need a Pet adapter. [Sintes] 41 PsychiatristObject +examine(obj:moodyobject) PetAdapter - pet : Pet +PetAdapter(obj:Pet) #getmood():string +querymood() HappyObject #getmood():string MoodyObject +querymood() #getmood():string CarefreeObject #getmood():string SadObject #getmood():string Pet +speak():string Pet Pet Adapter Adapter hides hides Pet Pet interface interface behind behind MoodyObject MoodyObject interface. interface. When When a request request comes comes into into PetAdapter, PetAdapter, it it delegates delegates to to the the Pet Pet instance instance as as needed. needed

22 PetAdapter.java public class PetAdapter extends MoodyObject { private Pet pet; public PetAdapter ( Pet pet ){ this.pet = pet; } protected String getmood(){ //MoodyObject requires us to implement this return pet.speak(); } } public void querymood(){ System.out.println ( getmood() ); } 43 Using PetAdapter PetAdapter dog = new PetAdapter ( new Dog() ); PetAdapter cat = new PetAdapter ( new Cat() ); PetAdapter bird = new PetAdapter ( new Bird() ); PsychiatristObject psychiatrist = new PsychiatristObject(); psychiatrist.examine( dog ); psychiatrist.examine( cat ); psychiatrist.examine( bird ); 44 22

23 Iterator Pattern Used with aggregate classes (container or collection classes) Aggregate object represents a group of related objects (e.g. java Vector) Common operation on aggregate object is iteration or sequential processing of each element 45 A tightly coupled example public void static clientcode(vector v) { Object obj = v.getfirst(); while (obj!= null) { process(obj); obj = v.getnext(); } } clientcode() is tightly coupled to the specific aggregate type Vector, even though a Vector is not necessarily required by the algorithm (could be ArrayList or other aggregate). The algorithm is also tightly coupled to the iteration implemented by class Vector

24 Iterator pattern removes coupling With Iterator pattern, clientcode can be made independent of a specific type of aggregate and independent of a specific iteration algorithm 47 Iterator Pattern Category : Behavioral Name: Iterator (a.k.a. Cursor) Problem: you want to loop over a collection of objects without becoming dependent upon the collection s implementation; if implementation of the collection or of the iteration changes, then it does not affect the client

25 Iterator Pattern : Solution Create abstract interface for iteration to be implemented by all classes that perform iteration Define abstract interface to be implemented by all aggregates. This interface should include a factory method which returns an object that implements the abstract interface for iteration. Define factory method in all aggregates which will create and return a class that implements the Iterator interface Write client code in terms of these two abstract interfaces. 49 Iterator Pattern Consequences: decoupled traversal simpler collection interface encapsulated looping logic Known uses:java s iterator and collection classes (see next slide) 50 25

26 Iterator Pattern: Structure <<interface>> Aggregate createiterator():iterator Client Factory Method <<interface>> Iterator next() isdone() currentitem(() Concrete Aggregate Concrete Iterator createiterator():iterator Spcific aggregate,such as list, linked list, etc. next() isdone() currentitem(() 51 UML Diagram of Java's Iterator and Collections <<interface>> Collection iterator():iterator <<interface>> Iterator hasnext():boolean next():object Vector iterator() LinkedList iterator() ArrayList iterator() Context Iterator hasnext():boolean next():object 52 26

27 Using Iterator Pattern public class IteratorExample() { public static void main(string[] args) { ArrayList arraylist = new ArrayList(); arraylist.add(new Integer(1)); arraylist.add(new Integer(2)); LinkedList linkedlist = new LinkedList(); linkedlist.add(new Integer(3)); linkedlist.add(new Integer(4)); } clientcode(arraylist); clientcode(linkedlist); 53 Using Iterator cont d } public static void clientcode(collection collection) { Iterator i = collection.iterator(); while (i.hasnext()) { Object obj = i.next(); String str = obj.tostring(); System.out.println(str + ); } System.out.println(); } Output:

28 Singleton Pattern Category : Creational Problem: ensure that a class has only one instance and provide global point of access to it Applicability: use where there must be exactly one instance of a class and it must be accessible to clients from a well-known access point (e.g. database) 55 Singleton Pattern Structure Singleton static getsingletoninstance() dosingletonoperation() getsingletondata() static theinstance SingletonData if (theinstance == 0) theinstance = new Singleton; return theinstance; 56 28

29 Singleton Pattern Participants : only one Singleton declares the unique instance of the class as a static variable and defines a static method getinstance() for clients to access the unique instance. 57 Singleton Pattern public class Singleton { public static Singleton getinstance() { return theinstance; } private constructor private Singleton() { //initialize instance fields } //. private static Singleton theinstance = new Singleton(); } 58 29

30 Strategy Pattern Category : behavioral Name : Strategy (a.k.a. Policy) Intent: define a family of algorithms, encapsulate each one and make them interchangeable 59 Strategy : Applicability Use Strategy pattern when many related classes differ only in behavior plotting different functions different variations of algorithm are needed sorts an algorithm uses data that clients should not know about LayoutManager in the AWT a class defines many behaviors which appear as multiple conditional statements in its methods 60 30

31 Strategy : Solution Create an abstract strategy class (or interface) and extend (or implement) it in numerous ways. Each subclass defines the same method names in different ways 61 Structure of Strategy Pattern Context strategy: Strategy contextinterface() STRATEGY <<interface>> Strategy algorithminterface() Concrete Strategy A algorithminterface() Concrete Strategy C algorithminterface() Concrete Strategy B algorithminterface() 62 31

32 Using the Strategy Pattern with Quicksort quicksort Pivot Strategy getpivot() pivotstrategy.getpivot(array,lo,hi) Select First Random Concrete Strategies Median of Three Strategy pattern resolves how to extend policies for selecting a pivot value without modifying main quicksort algorithm 63 Java Example of Strategy this.setlayout( new FlowLayout( ) ); this.setlayout( new GridLayout( ) ); In Java, a container contains a layout manager There is a default perhaps set in the constructor You can change a container's layout manager with a setlayout message [Mercer] 64 32

33 Java interface LayoutManager Java has a java.awt.layoutmanager interface Known Implementing Classes GridLayout, FlowLayout, ScrollPaneLayout Each class implements the following methods addlayoutcomponent(string name, Component comp) layoutcontainer(container parent) minimumlayoutsize(container parent) preferredlayoutsize(container parent) removelayoutcomponent(component comp) [Mercer] 65 UML Diagram of LayoutManager JPanel panel: Panel size: Dimension layoutboss: LayoutManager setlayout(lm: LayoutManager) setpreferredsize(di:dimension) <<interface>> LayoutManager addlayoutcomponent () layoutcontainer() minimumlayoutsize() implements [Mercer] GridLayout addlayoutcomponent () layoutcontainer() minimumlayoutsize() FlowLayout addlayoutcomponent () layoutcontainer() minimumlayoutsize() ScrollPaneLayout addlayoutcomponent () layoutcontainer() minimumlayoutsize() 66 33

34 Change the strategy at runtime Demonstrate LayoutControllerFrame.java private class FlowListener implements ActionListener { // There is another ActionListener for GridLayout public void actionperformed( ActionEvent evt ) { // Change the layout strategy of the JPanel // and tell it to lay itself out centerpanel.setlayout( new FlowLayout( ) ); centerpanel.validate( ); } } [Mercer] 67 Factory Method Pattern : background Java Collection interface defines Iterator iterator() Each subclass of Collection (LinkedList, etc) implements the method differently Each iterator method returns object of a class that implements Iterator interface, but implementation of subclasses are different 68 34

35 Factory Method Pattern : background If every collection had its own iterator, you wouldn t know which type of iterator to construct. For example, assume: LinkedList list =.; Iterator iter = new LinkedListIterator(list); But if LinkedList is a Collection, then we wouldn t know which iterator type to construct Collection coll = ; Iterator iter = new????(coll); 69 Factory Method Pattern : background Polymorphism saves the day: Iterator iter = coll.iterator(); calls the iterator method of the class the collection object belongs to The iterator method constructs an object of some class that implements the Iterator interface

36 Factory Method Pattern The iterator method is called a Factory Method A Factory Method can construct objects of subclasses, not just a fixed class 71 Factory Method Pattern Category : Creational Name: Factory Method Problem : provide a common interface for creating subclasses. A class needs to instantiate a derivation of another class, but doesn t know which one. Factory Method allows a derived class to make this decision

37 Factory Method : Intent GoF: Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses. 73 Factory Method : Context A type (called the creator) creates objects of another type (called the product) Subclasses of creator need to create different kinds of product objects Clients don t need to know exact type of product objects 74 37

38 Factory Method : Solution Define an abstract interface for the new object or product to be created. This type will express commonality of all products. Define an abstract class for creating the product. This type will express commonality of all creators. Define a method, called factory method, in the creator interface. The factory method yields a product object. Each concrete creator class implements the factory method so that it returns an object of a concrete product class. 75 UML Diagram for Factory Method Design Pattern <<interface>> AbstractCreator createproduct():abstractproduct <<interface>> AbstractProduct FactoryMethod ConcreteCreator createproduct():abstractproduct ConcreteProduct 76 38

39 FactoryMethod in Java The Java API has many classes with the word factory in their name: BasicIconFactory, BorderFactory, CertificateFactory, etc. Not all of these classes implement the Factory Method design pattern. In the Java API, any class that creates another class may have the word factory in its name. It may or may not follow the factory design pattern discussed here 77 Factory Method and Java Classes that implement the Factory Method design pattern follow a general template: // Visible to the client is an abstract class with the word // factory in its name. abstract public class SomethingFactory { // Clients start by calling this public static method. // This method returns a reference to a concrete //subclass of this class. The specific class created //and returned is usually determined by a system //property. public static SomethingFactory newinstance(); // This is the factory method. // Concrete subclasses will override this method and // decide the specific type of product created. public abstract AbstractProduct thefactorymethod(); }//end SomethingFactory // Also visible to the client is the abstract product interface with its own domain-specific methods. abstract public class AbstractProduct { public abstract void productmethod(); }//end AbstractProduct 78 39

40 Using Factory Method in Parsing XML A specific example of the Factory Method design pattern can be found in the Java API for XML parsing. Java defines an interface for XML parsing in a way that is independent of a specific parser implementation. A Java program that processes XML data can use parsers from different vendors without a source code change in the Java program. To facilitate this the Java XML API uses the Factory Method design pattern. 79 Parsing XML In Java before you can process an XML document you must obtain a parser. Java's API for XML parsing defines interfaces for two types of parsers: 1. SAX, and 2. DOM The class DocumentBuilderFactory is used to create a DOM parser: 80 40

41 DocumentBuilderFactory(1) // Note, some methods have been left off to simplify this example. abstract public class DocumentBuilderFactory { // This method returns a subclass of DocumentBuilderFactory based on a // system property. public static DocumentBuilderFactory newinstance(); public abstract DocumentBuilder newdocumentbuilder(); } abstract public class DocumentBuilder { public abstract Document parse(inputstream is); } 81 DocumentBuilderFactory(2) The client calls the public static method newinstance() to obtain an instance of the factory class DocumentBuilderFactory. The specific factory returned is based on properties set at runtime. The factory class returned determines what type of parser is created when the client calls the factory method newdocumentbuilder(). The interface onto the parser is defined by the abstract class DocumentBuilder

42 State Pattern Name: State Problem: Objects have state and behavior. Objects change their state based on internal and external events. If an object goes through clearly identifiable states, and the object's behavior is especially dependent on it's state, it is a good candidate for the State design pattern. 83 State Pattern : Solution Encapsulate the state-specific behavior into separate objects and have the context delegate state-specific requests to these objects

43 State Pattern : UML Diagram 85 State Pattern A separate concrete class is created for each identifiable state. State-specific behavior is encapsulated in these classes. An abstract interface is defined for these classes(abstractstate in the diagram). The context (class that has different states) holds a private reference to a state object. State-dependent methods in the context class are forwarded to the state object. Some mechanism is provided for moving between states

44 State Pattern Here are 3 options for moving between states: 1. The client of the context can take responsibility for setting the state of the context. 2. The Context can take responsibility. 3. The states can take responsibility. 87 Decorator Pattern Category : Structural Name : Decorator Problem : Goal is to add more responsibilities to an object dynamically, avoiding subclassing. Example: add scrolling to a text view. The scrolling object surrounds the text view, handles mechanics of the scroll bar, then tells text view to display itself appropriately. [GoF] 88 44