Software Quality Management

Transcription

1 Marco Scotto

2 Outline Structural Patterns Adapter Composite Decorator 2

3 Design Pattern Space Purpose Creational Structural Behavioral Scope Class Factory Method Adapter Interpreter Template Method Object Abstract Factory Builder Prototype Singleton Adapter Bridge Composite Decorator Façade Proxy Chain of Responsibility Command Iterator Mediator Memento Flyweight Observer State Strategy Visitor 3

4 Adapter (1/3) Intent Convert the interface of a class into another interface clients expect. Adapter lets classes work together that could not otherwise because of incompatible interfaces Also Known As Wrapper 4

5 Adapter (2/3) Motivation Sometimes a toolkit or class library can not be used because its interface is incompatible with the interface required by an application We cannot change the library interface, since we may not have its source code Even if we did have the source code, we probably should not change the library for each domain-specific application 5

6 Adapter (3/3) Example 6

7 Structure (1/2) A class adapter uses multiple inheritance to adapt one interface to another: 7

8 Structure (2/2) An object adapter relies on object composition: 8

9 Applicability Use the Adapter pattern when: You want to use an existing class, and its interface does not match the one you need You want to create a reusable class that cooperates with unrelated classes with incompatible interfaces 9

10 Implementation Issues How much adapting should be done? Simple interface conversion that just changes operation names and order of arguments Totally different set of operations Does the adapter provide two-way transparency? A two-way adapter supports both the Target and the Adaptee interface It allows an adapted object (Adapter) to appear as an Adaptee object or a Target object 10

11 Adapter Pattern Example 1 (1/6) Round pegs and square pegs SquarePeg class: /** * The SquarePeg class. * This is the Target class. */ public class SquarePeg { public void insert(string str) { System.out.println("SquarePeg insert(): " + str); 11

12 Adapter Pattern Example 1 (2/6) RoundPeg class: /** * The RoundPeg class. * This is the Adaptee class. */ public class RoundPeg { public void insertintohole(string msg) { System.out.println( "RoundPeg insertintohole(): " + msg); 12

13 Adapter Pattern Example 1 (3/6) If a client only understands the SquarePeg interface for inserting pegs using the insert() method, how can it insert round pegs? Using a peg adapter 13

14 Adapter Pattern Example 1 (4/6) PegAdapter class: /** * The PegAdapter class. * This is the Adapter class. * It adapts a RoundPeg to a SquarePeg. * Its interface is that of a SquarePeg. */ public class PegAdapter extends SquarePeg { private RoundPeg roundpeg; public PegAdapter(RoundPeg peg) { this.roundpeg = peg; public void insert(string str) { roundpeg.insertintohole(str); 14

15 Adapter Pattern Example 1 (5/6) Typical client program: // Test program for Pegs. public class TestPegs { public static void main(string args[]) { // Create some pegs. RoundPeg roundpeg = new RoundPeg(); SquarePeg squarepeg = new SquarePeg(); // Do an insert using the square peg. squarepeg.insert("inserting square peg..."); 15

16 Adapter Pattern Example 1 (6/6) // Now we'd like to do an insert using the round peg. // But this client only understands the insert() // method of pegs, not a insertintohole() method. // The solution: create an adapter that adapts // a square peg to a round peg! PegAdapter adapter = new PegAdapter(roundPeg); adapter.insert("inserting round peg..."); Client program output: SquarePeg insert(): Inserting square peg... RoundPeg insertintohole(): Inserting round peg... 16

17 Adapter Pattern Example 2 (1/6) Notice in Example 1 that the PegAdapter adapts a RoundPeg to a SquarePeg. The interface for PegAdapter is that of a SquarePeg What if we want to have an adapter that acts as a SquarePeg or a RoundPeg? Such an adapter is called a two-way adapter One way to implement two-way adapters is to use multiple inheritance, but we cannot do this in Java But we can have our adapter class implement two different Java interfaces 17

18 Adapter Pattern Example 2 (2/6) Interfaces for round and square pegs: /** *The IRoundPeg interface. */ public interface IRoundPeg { public void insertintohole(string msg); /** *The ISquarePeg interface. */ public interface ISquarePeg { public void insert(string str); 18

19 Adapter Pattern Example 2 (3/6) New RoundPeg and SquarePeg classes. These are essentially the same as before except they now implement the appropriate interface // The RoundPeg class. public class RoundPeg implements IRoundPeg { public void insertintohole(string msg) { System.out.println( "RoundPeg insertintohole(): " + msg); // The SquarePeg class. public class SquarePeg implements ISquarePeg { public void insert(string str) { System.out.println("SquarePeg insert(): " + str); 19

20 Adapter Pattern Example 2 (4/6) And here is the new PegAdapter: /** * The PegAdapter class. * This is the two-way adapter class. */ public class PegAdapter implements ISquarePeg, IRoundPeg { private RoundPeg roundpeg; private SquarePeg squarepeg; public PegAdapter(RoundPeg peg) {this.roundpeg = peg; public PegAdapter(SquarePeg peg) {this.squarepeg = peg; public void insert(string str) {roundpeg.insertintohole(str); public void insertintohole(string msg){squarepeg.insert(msg); 20

21 Adapter Pattern Example 2 (5/6) A client that uses the two-way adapter: // Test program for Pegs. public class TestPegs { public static void main(string args[]) { // Create some pegs. RoundPeg roundpeg = new RoundPeg(); SquarePeg squarepeg = new SquarePeg(); // Do an insert using the square peg. squarepeg.insert("inserting square peg..."); // Create a two-way adapter and do an insert with it. ISquarePeg roundtosquare = new PegAdapter(roundPeg); roundtosquare.insert("inserting round peg..."); 21

22 Adapter Pattern Example 2 (6/6) // Do an insert using the round peg. roundpeg.insertintohole("inserting round peg..."); // Create a two-way adapter and do an insert with it. IRoundPeg squaretoround = new PegAdapter(squarePeg); squaretoround.insertintohole("inserting square peg..."); Client program output: SquarePeg insert(): Inserting square peg... RoundPeg insertintohole(): Inserting round peg... RoundPeg insertintohole(): Inserting round peg... SquarePeg insert(): Inserting square peg... 22

23 Adapter Pattern Example 3 (1/3) Situation A Java class library exists for creating CGI web server programs One class in the library is the CGIVariables class which stores all CGI environment variables in a hash table and allows access to them via a get(string evname) method The latest version of the web server supports servlets, which provide functionality similar to CGI programs, but are considerably more efficient. The servlet library has an HttpServletRequest class which has a getx() method for each CGI environment variable. We want to use servlets. Should we rewrite all of our existing Java CGI programs? 23

24 Adapter Pattern Example 3 (2/3) Solution: We have to do some rewriting, but let's attempt to minimize things We can design a CGIAdapter class which has the same interface (a get() method) as the original CGIVariables class, but which puts a wrapper around the HttpServletRequest class Our CGI programs must now use this CGIAdapter class rather than the original CGIVariables class, but the form of the get() method invocations need not change 24

25 Adapter Pattern Example 3 (3/3) Here's a snippet of the CGIAdapter class: public class CGIAdapter { Hashtable CGIVariables = new Hashtable(20); public CGIAdapter(HttpServletRequest CGIEnvironment) { CGIVariables.put("AUTH_TYPE", CGIEnvironment.getAuthType()); CGIVariables.put("REMOTE_USER", CGIEnvironment.getRemoteUser()); // etc. public Object get(object key) {return CGIvariables.get(key); Note that in this example, the Adapter class (CGIAdapter) itself constructs the Adaptee class (CGIVariables) 25

26 Adapter Pattern Example 4 (1/6) Situation Consider a utility class that has a copy() method which can make a copy of an vector excluding those objects that meet a certain criteria To accomplish this the method assumes that all objects in the vector implement the Copyable interface providing the iscopyable() method to determine if the object should be copied or not 26

27 Adapter Pattern Example 4 (2/6) 27

28 Adapter Pattern Example 4 (3/6) Copyable interface: public interface Copyable { public boolean iscopyable(); copy() method of the VectorUtilities class: public static Vector copy(vector vin) { Vector vout = new Vector(); Enumeration e = vin.elements(); while (e.hasmoreelements()) { Copyable c = (Copyable) e.nextelement(); if (c.iscopyable()) vout.addelemet(c); return vout; 28

29 Adapter Pattern Example 4 (4/6) But what if we have a class, say the Document class, that does not implement the Copyable interface We want to be able perform a selective copy of a vector of Document objects, but we do not want to modify the Document class at all To make things simple, let s assume that the Document class has a nice isvalid() method we can invoke to determine whether or not it should be copied 29

30 Adapter Pattern Example 4 (5/6) New class diagram: 30

31 Adapter Pattern Example 4 (6/6) DocumentAdapter class: public class DocumentAdapter implements Copyable { private Document d; public DocumentAdapter(Document d) { document = d; public boolean iscopyable() { return d.isvalid(); 31

32 Pattern Example 5 Adapter (1/4) Do you see any Adapter pattern here? public class ButtonDemo { public ButtonDemo() { Button button = new Button("Press me"); button.addactionlistener(new ActionListener() { public void actionperformed(actionevent e) { dooperation(); ); public void dooperation() { whatever 32

33 Pattern Example 5 Adapter (2/4) Button objects expect to be able to invoke the actionperformed() method on their associated ActionListener objects But the ButtonDemo class does not have this method It really wants the button to invoke its dooperation() method The anonymous inner class we instantiated acts as an adapter object, adapting ButtonDemo to ActionListener 33

34 Pattern Example 5 Adapter (3/4) Recall that there are some AWT listener interfaces that have several methods which must be implemented by an event listener For example, the WindowListener interface has seven such methods In many cases, an event listener is really only interested in one specific event, such as the Window Closing event 34

35 Pattern Example 5 Adapter (4/4) Java provides adapter classes as a convenience in this situation For example, the WindowAdapter class implements the WindowListener interface, providing do nothing implementation of all seven required methods An event listener class can extend WindowAdapter and override only those methods of interest And now we see why they are called adapter classes 35

36 Composite Pattern (1/3) Intent Compose objects into tree structures to represent part-whole hierarchies Composite lets clients treat individual objects and compositions of objects uniformly This is called recursive composition 36

37 Composite Pattern (2/3) 37

38 Composite Pattern (3/3) Example 38

39 Applicability Use the Composite pattern when You want to represent part-whole hierarchies of objects You want clients to be able to ignore the difference between compositions of objects and individual objects. Clients will treat all objects in the composite structure uniformly 39

40 Structure 40

41 Composite Pattern (1/2) A typical Composite object structure might look like this: 41

42 Composite Pattern (2/2) Consequences Benefits It makes it easy to add new kinds of components It makes clients simpler, since they do not have to know if they are dealing with a leaf or a composite component Liabilities It makes it harder to restrict the type of components of a composite 42

43 Implementation Issues (1/2) A composite object knows its contained components, that is, its children Should components maintain a reference to their parent component? Depends on application, but having these references supports the Chain of Responsibility pattern 43

44 Implementation Issues (2/2) Where should the child management methods (add(), remove(), getchild()) be declared? In the Component class: Gives transparency, since all components can be treated the same But it is not safe, since clients can try to do meaningless things to leaf components at run-time In the Composite class: Gives safety, since any attempt to perform a child operation on a leaf component will be caught at compile-time But we lose transparency, since now leaf and composite components have different interfaces 44

45 Composite Pattern (1/2) Transparent vs. Safe 45

46 Composite Pattern (2/2) Implementation Issues Should Component maintain the list of components that will be used by a composite object? That is, should this list be an instance variable of Component rather than Composite? Better to keep this part of Composite and avoid wasting the space in every leaf object Is child ordering important? Depends on application Who should delete components? Not a problem in Java. The garbage collector will come to the rescue What's the best data structure to store components? Depends on application 46

47 Composite Pattern Example 1 (1/8) Situation: A GUI system has window objects which can contain various GUI components (widgets) such as, buttons and text areas. A window can also contain widget container objects which can hold other widgets. Solution 1 What if we designed all the widgets with different interfaces for "updating" the screen? We would then have to write a Window update() method as follows: 47

48 Composite Pattern Example 1 (2/8) public class Window { Button[] buttons; Menu[] menus; TextArea[] textareas; WidgetContainer[] containers; public void update() { if (buttons!= null) for (int k = 0; k < buttons.length; k++) buttons[k].draw(); if (menus!= null) for (int k = 0; k < menus.length; k++) menus[k].refresh(); // Other widgets handled similarly. if (containers!= null) for (int k = 0; k < containers.length; k++ ) containers[k].updatewidgets();... 48

49 Composite Pattern Example 1 (3/8) It looks particularly bad It violates the Open-Closed Principle If we want to add a new kind of widget, we have to modify the update() method of Window to handle it 49

50 Composite Pattern Example 1 (4/8) Solution 2 We should always try to program to an interface, right? So, let's make all widgets support the Widget interface, either by being subclasses of a Widget class or implementing a Java Widget interface Now our update() method becomes: 50

51 Composite Pattern Example 1 (5/8) public class Window { Widget[] widgets; WidgetContainer[] containers; public void update() { if (widgets!= null) for (int k = 0; k < widgets.length; k++) widgets[k].update(); if (containers!= null) for (int k = 0; k < containers.length; k++ ) containers[k].updatewidgets(); 51

52 Composite Pattern Example 1 (6/8) It looks better but we are still distinguishing between widgets and widget containers 52

53 Composite Pattern Example 1 (7/8) Solution 3: The Composite pattern 53

54 Composite Pattern Example 1 (8/8) Now the update method looks like: public class Window { Component[] components; public void update() { if (components!= null) for (int k = 0; k < components.length; k++) components[k].update(); 54

55 Composite Pattern Example 2 - The Java AWT Composite Pattern 55

56 Composite Pattern Example 3 Situation: Many types of manufactured systems, such as computer systems and stereo systems, are composed of individual components and sub-systems that contain components For example, a computer system can have various chassis that contain components (hard-drive chassis, power-supply chassis) and busses that contain cards The entire system is composed of individual components (floppy drives, cd-rom drives), busses and chassis 56

57 Composite Pattern Example 3 Solution: Use the Composite pattern 57

58 Decorator Pattern (1/4) Intent Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality Also Known As Wrapper Motivation We want to add properties, such as borders or scrollbars to a GUI component. We can do this with inheritance (subclassing), but this limits our flexibility A better way is to use composition 58

59 Decorator Pattern (2/4) 59

60 Decorator Pattern (3/4) Motivation 60

61 Decorator Pattern (4/4) Motivation 61

62 Applicability Use Decorator: To add responsibilities to individual objects dynamically without affecting other objects When extension by subclassing is impractical Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for subclassing 62

63 Structure 63

64 Decorator Example 1 (1/11) Let s look at the motivation for the Decorator pattern in a little more detail Suppose we have a TextView GUI component and we want to add different kinds of borders and scrollbars to it Suppose we have three types of borders: Plain 3D Fancy And two types of scrollbars: Horizontal Vertical 64

65 Decorator Example 1 (2/11) Solution 1: Let s use inheritance first. We generate subclasses of TextView for all the required cases We need the 15 subclasses: TextView-Plain TextView-Fancy TextView-3D TextView-Horizontal TextView-Vertical TextView-Horizontal-Vertical TextView-Plain-Horizontal TextView-Plain-Vertical TextView-Plain-Horizontal-Vertical TextView-3D-Horizontal TextView-3D-Vertical TextView-3D-Horizontal-Vertical TextView-Fancy-Horizontal TextView-Fancy-Vertical TextView-Fancy-Horizontal-Vertical 65

66 Decorator Example 1 (3/11) There are several disadvantages to this technique: We already have an explosion of subclasses. What if we add another type of border? Or an entirely different property? We have to instantiate a specific subclass to get the behavior we want This choice is made statically and a client can't control how and when to decorate the component 66

67 Decorator Example 1 (4/11) Solution 2: Let s use the Strategy pattern 67

68 Decorator Example 1 (5/11) Now the TextView Class looks like this: public class TextView extends Component { private Border border; private Scrollbar sb; public TextView(Border border, Scrollbar sb) { this.border = border; this.sb = sb; public void draw() { border.draw(); sb.draw(); // Code to draw the TextView object itself. 68

69 Decorator Example 1 (6/11) Using the Strategy pattern we can add or change properties to the TextView component dynamically. For example, we could have mutators for the border and scroll bar attributes and we could change them at run-time But note that the TextView object itself had to be modified and it has knowledge of borders and scrollbars If we wanted to add another kind of property or behavior, we would have to again modify TextView 69

70 Decorator Example 1 (7/11) Solution 3: Let s turn Strategy inside out to get the Decorator pattern 70

71 Decorator Example 1 (8/11) Now the TextView class knows nothing about borders and scrollbars: public class TextView extends Component { public void draw() { // Code to draw the TextView object itself. 71

72 Decorator Example 1 (9/11) But the decorators need to know about components: public class FancyBorder extends Decorator { private Component component; public FancyBorder(Component component) { this.component = component; public void draw() { component.draw(); // Code to draw the FancyBorder object itself. 72

73 Decorator Example 1 (10/11) Now a client can add borders as follows: public class Client { public static void main(string[] args) { TextView data = new TextView(); Component borderdata = new FancyBorder(data); Component scrolleddata = new VertScrollbar(data); Component borderandscrolleddata = new HorzScrollbar(borderData); 73

74 Decorator Example 1 (11/11) Decorator Changing the skin of an object Strategy Changing the guts of an object 74

75 Decorator Example 2 (1/3) Java I/O classes use the Decorator pattern The basic I/O classes are InputStream, OutputStream, Reader and Writer. These classes have a very basic set of behaviors We would like to add additional behaviors to an existing stream to yield, for example: Buffered Stream Adds buffering for the stream Data Stream Allows I/O of primitive Java data types Pushback Stream Allows undo operation We really do not want to modify the basic I/O classes to achieve these behaviors, so we use decorator classes, which Java calls filter classes, to add the desired properties using composition 75

76 Decorator Example 2 (2/3) Some examples of the decorator (filter) classes are: BufferedInputStream DataInputStream PushbackInputStream The constructors for these classes take an InputStream object 76

77 Decorator Example 2 (3/3) Here is an example of the use of these classes: public class JavaIO { public static void main(string[] args) { // Open an InputStream. FileInputStream in = new FileInputStream("test.dat"); // Create a buffered InputStream. BufferedInputStream bin = new BufferedInputStream(in); // Create a buffered, data InputStream. DataInputStream dbin = new DataInputStream(bin); // Create an unbuffered, data InputStream. DataInputStream din = new DataInputStream(in); // Create a buffered, pushback, data InputStream. PushbackInputStream pbdbin = new PushbackInputStream(dbin); 77