CSA 1019 Imperative and OO Programming

Transkript

1 CSA 1019 Imperative and OO Programming Design Patterns Mr. Charlie Abela Dept. of of Artificial Intelligence

2 Objectives Getting familiar with Defining design patterns Catalog Perspective Object Oriented Approach Design Patterns Templates Design Patterns Categories Design Patterns Considered Charlie Abela CSA1019: Design Patterns 2

3 Defining Design Patterns If If a problem occurs over and over again, and a solution to to that problem has been used effectively. That solution can be be described as as a pattern. Design patterns are language-independent strategies for for solving common objectoriented design problems. Design patterns are are just convenient ways of of reusing object-oriented code between projects and between programmers. The idea behind design patterns is is simple-- write down and catalogue common interactions between objects that programmers have frequently found useful. One of of the the most influential works about design patterns was published in in the the book, Design Patterns Elements of of Reusable Software, by by Gamma, Helm, Johnson and Vlissides.(1995). This book is is commonly referred to to as as the the Gang of of Four or or GoF book Charlie Abela CSA1019: Design Patterns 3

4 Popular Design Pattern One One of of the the most most frequently cited cited frameworks is is the the Model-View-Controller framework for for Smalltalk [Krasner and and Pope, 1988], which divided the the user user interface problem into into three three parts. The The parts parts were were referred to to as as a data data model model which which contain contain the the computational parts parts of of the the program, the the view view which which presented the the user user interface, and and the the controller, which which interacted between between the the user user and and the the view. view. Each Each of of these these aspects of of the the problem is is a separate object and and each each has has its its own own rules rules for for managing its its data. data. Communication between the the user, user, the the GUI GUI and and the the data data should be be carefully controlled and and this this separation of of functions accomplished that that very very nicely. Three objects talking to to each each other other using this this restrained set set of of connections is is an an example of of a powerful design pattern. Charlie Abela CSA1019: Design Patterns 4

5 UML Class diagrams in one slide Charlie Abela CSA1019: Design Patterns 5

6 Object Oriented Approach The The fundamental reason for for using various design patterns is is to to keep keep classes separated and and prevent them them from from having to to know too too much about one one another. There are are a number of of strategies that that OO OO programmers use use to to achieve this this separation, among them them encapsulation and and inheritance. Inheritance is is one one of of the the most most important capabilities of of OO OO since since a a class class that that inherits inherits from from a a parent parent class class has has access access to to all all of of the the public public methods and and variables of of that that parent parent class. class. However by by starting your your inheritance hierarchy with with a complete, concrete class class you you may may be be unduly restricting yourself as as well well as as carrying along specific method implementation baggage. Instead, it it is issuggested that that you you always Program to to an an interface and and not not to to an an implementation More succinctly one one should always define the the top top of of any any class class hierarchy with with an an abstract class, which implements no no methods, but but simply defines the the methods that that the the class class will will support. Then, in in all all of of the the derived classes there there is is more more freedom to to implement these these methods as as most most suits suits the the purposes. Charlie Abela CSA1019: Design Patterns 6

7 Object Oriented Approach (cont) The other major concept one should recognize is is that of of object composition. This is is simply the the construction of of objects that contain other objects: put simply, encapsulation of of several objects inside another one. While many junior OO programmers use inheritance to to solve every problem, for for more elaborate programs, one has to to consider object composition. The new object can have the the interface that is is best for for what needs to to be be accomplished without having all all the the methods of of the the parent classes. Thus, the the second major precept suggested by by Design Patterns is: is: Favour object composition over inheritance. At At first this seems contrary to to the the customs of of OO programming, however this is is frequently used in in different cases among the the design patterns where the the inclusion of of one or or more objects inside another is is the the preferred approach. Charlie Abela CSA1019: Design Patterns 7

8 Example Inheritance class class Fruit Fruit { //... //... } class class Apple Apple extends Fruit Fruit { //... //... } Composition public class class Fruit Fruit { //... //... } public class class Apple{ private Fruit Fruit fruit fruit = new new Fruit(); //... //... } Fruit Fruit Apple Apple - Fruit: fruit Charlie Abela CSA1019: Design Patterns 8

9 Design Patterns Catalogue Design Patterns, as as described in in the GOF book are considered to to be a catalogue of of 23 generally useful patterns for writing object-oriented software. It It is is written as as a catalogue with short examples and substantial discussions of of how the patterns can be constructed and applied. Charlie Abela CSA1019: Design Patterns 9

10 Design Patterns Templates Design patterns are are generally described using a consistent format making them more easy to to learn, compare and use. Design Patterns (in (in the the GOF book) uses the the following template: Pattern name and and classification: A conceptual handle and and category for for the the pattern Intent: What problem does does the the pattern address? Also Also known as: as: Other common names for for the the pattern Motivation: A scenario that that illustrates the the problem Applicability: In In what what situations can can the the pattern be be used? Structure: Diagram using the the Object Modelling Technique (OMT). Participants: Classes and and objects in in design Collaborations: How How classes and and objects in in the the design collaborate Charlie Abela CSA1019: Design Patterns 10

11 Design Patterns Templates (cont) Consequences: The main objectives that the the pattern achieves and the the tradeoffs involved Implementation: Pitfalls and hints that one should be be aware of of when implementing the the pattern Sample code: Sample code in in illustrating possible implementation Known uses: Examples of of the the use of of the the pattern in in the the real world Related patterns: other design patterns which are are closely related to to this pattern Charlie Abela CSA1019: Design Patterns 11

12 Design Patterns Templates (cont) The book, Patterns in in Java uses a slightly different type of of template and the the implementation is is based on on Java. Template includes: Pattern Name: The The name and and a reference to to where it it was was first first described Synopsis: A very very short short description of of the the pattern Context: A description of of the the problem the the pattern is is intended to to solve Forces: A description of of the the considerations that that lead lead to to the the solution Solution: A description of of the the general solution Consequences: Implications of of using the the pattern Implementation: Implementation details to to consider Java Java API API Usage: When available, an an example from from the the Java Java API API is is mentioned Code example: A code code example in in the the Java Java language Related patterns: A list list of of related patterns Charlie Abela CSA1019: Design Patterns 12

13 Design Pattern Categories The three main categories as as defined by the GOF book are: Creational patterns are are ones that create objects for for you, rather than having you instantiate objects directly. This gives programs more flexibility in in deciding which objects need to to be be created for for a given case. Structural patterns help in in composing groups of of objects into larger structures, such as as complex user interfaces or or accounting data. Behavioural patterns help define the the communication between objects in in the the system and how the the flow is is controlled in in a complex program. Charlie Abela CSA1019: Design Patterns 13

14 Design Patterns Considered The The following design patterns will will be be considered (following slides taken from from Design Patterns slides compiled by by Patrick Abela) Design Pattern Factory Method (Creational) Brief Description Creating different objects through subclassing of factory class. Abstract (Creational) Singleton (Creational) Adapter (Structural) Decorator (Structural) Factory Managing families of objects through interfaces Creating a single instance for the system Changing interfaces of an object Changing responsibilities of an object without subclassing Observer (Behavioural) Strategy (Behavioural) Varying number of objects that depend on another object. Changing algorithm of an object Charlie Abela CSA1019: Design Patterns 14

15 Creational Patterns Creational design patterns abstract the the instantiation process. Their aim aim is is that that of of helping make a system independent of of how how its its objects are are created, composed and and represented. These patterns give give flexibility in in what gets gets created, who who creates it, it, how howit it gets gets created, and and when. We We shall shall be be using an an example, building a maze for for a computer game, to to illustrate how how the the design of of the the system varies from from one one pattern to to another. We We shall shall be be focusing only only on on the the parts parts that that are are important for for creating a maze, ignoring other other details such such as as players, display operations and and position of of players. In In our our example a maze consists of of the the following: MazeComponent: Superclass for for all all components Room: Room: A class class which which has has reference to to four four doors/walls Door: Door: A class class which which has has reference to to two two rooms rooms (exit, (exit, entrance) Wall: Wall: A class class which which represents a a wall wall object object Maze: Maze: A class class that that represents a a collection of of Rooms Rooms MazeGame: A class class which which maintains references to to rooms rooms and and which which defines defines method method createmaze(). Charlie Abela CSA1019: Design Patterns 15

16 MazeGame Example MazeComponent enter() addroom() roomno() Maze rooms Room roomnumber enter() setside() getside() enter() Wall isopen enter() Door A maze is is a collection of of rooms Rooms, walls and and doors are are all all maze maze components A room maintains a reference to to other other maze components if if a player player is is in in a room room and and he he goes goes east, east, the the game game can can determine which which maze maze component is is immediately to to the the east east and and call call enter() enter() Charlie Abela CSA1019: Design Patterns 16

17 Creating a Maze Consider the the following createmaze() method :: Maze Maze m = new new Maze(); Room Room r1 r1 = new new Room(1); // // create room room 1 Room Room r2 r2 = new new Room Room (2); (2); // // create room room 2 Door Door d = new new Door Door (r1, (r1, r2); r2); r1.setside(north, new new Wall); r1.setside(east, d); d); r1.setside(south, new new Wall); r1.setside (West, new new Wall); r2.setside(north, new new Wall); r2.setside(east, d); d); r2.setside(south, new new Wall); r2.setside (West, new new Wall); m.addroom(r1); m.addroom(r2); The The problem with with this this method is is its its inflexibility the the maze layout is is hardcoded. Changing the the layout means changing this this method. The The creational patterns which we we are are going to to consider show ways ways of of how how to to make this this design more more flexible. Charlie Abela CSA1019: Design Patterns 17

18 Factory Method Design Pattern (Creational) Suppose we we wanted to to reuse an an existing maze layout for for a new new game containing enchanted components. The The new new game will will have have new new components such such as as DoorNeedingSpell (door can can be be locked and and opened with with a spell), RoomWithABomb and and BombedWall which are are subclasses of of Door, Room, Wall Wallrespectively. The The way way the the system has has been been designed does does not not allow us us to to recreate the the maze with with different components as as the the createmaze() method creates instances of of specific classes. To To handle this this issue issue we we can can make use use of of the the Factory Method design pattern. The The idea idea of of this this design pattern is is that that of of creating factory methods such such as as makeroom(), makewall() etc. etc. createmaze() creates components by by invoking these these methods rather then then by by using direct class class constructors The The MazeGame class class can can be be then then subclassed (overriding the the factory methods makeroom(), makewall() etc. etc. methods) to to create variations of of the the same same layout. Charlie Abela CSA1019: Design Patterns 18

19 Using Factory Method public class class MazeGame { public Maze Maze makemaze(){return new new Maze();} public Room Room makeroom( ){ return new new Room( );} public Wall Wall makewall() {return } } public Door Door makedoor() { } } public Maze Maze createmaze() { Maze Maze m = makemaze(); Room Room r1 r1 = makeroom(1); // // create room room 1 Room Room r2 r2 = makeroom(2); // // create room room 2 Door Door d = makedoor(r1, r2); r2); m.addroom(r1); m.addroom(r2); r1.setside(north, new new Wall); r1.setside(east, d); d); r1.setside(sourth, New New Wall); r1.setside (West, new new Wall); } To To create create the the same same Maze Maze with with RoomWithABomb, BombedWall, DoorNeedingSpell components, then then an an EnchantedMazeGame, subclass subclass of of MazeGame can can be be made made to to override override the the makeroom, makewall and and makedoor appropriately. Charlie Abela CSA1019: Design Patterns 19

20 Using Factory Method (cont) Consider this EnchantedMazeGame class: public class class EnchantedMazeGame extends MazeGame{ public Room Room makeroom(int n){ n){ return new new EnchantedRoom(n);} public Wall Wall makewall(){ return new new EnchantedWall();} public Door Door makedoor(room r1, r1, Room Room r2){ r2){ return new new EnchantedDoor(r1, r2);} r2);} } The createmaze() method of of MazeGame is is inherited by EnchantedMazeGame and can be used to to create regular mazes or or enchanted mazes without modification! Charlie Abela CSA1019: Design Patterns 20

21 Factory Method Structure The The structure section section of of the the Factory Factory Method Method design design pattern pattern defines defines the the structure of of the the design design pattern pattern as as follows: follows: (refer (refer to to book book for for more more details details on on pattern) pattern) Product defines defines the the interface of of objects objects the the factory factory method method creates creates ConcreteProduct implements the the Product Product interface Creator declares declares the the factory factory method method which which returns returns an an object object of of type type Product. Calls Calls also also the the factory factory method method to to create create a a Product Product object. object. ConcreteCreator- overrides the the factory factory method method to to return return an an instance instance of of a a ConcreteProduct. In In the the Maze Maze example :: Product corresponds to to MazeComponent interface ConcreteProduct corresponds to to Wall Wall Creator corresponds to to MazeGame class class ConcreteCreator corresponds to to EnchantedMaze. Charlie Abela CSA1019: Design Patterns 21

22 Abstract Factory Design Pattern (Creational) The Abstract Factory is is a more elaborate design pattern which builds on on the the Factory Method design pattern. One difference between the the two is is that with the the Abstract Factory pattern, a class delegates the the responsibility of of object instantiation to to another object via via composition whereas the the Factory Method pattern uses inheritance and relies on on a subclass to to handle the the desired object instantiation. The idea is is that of of defining interfaces for for the the factory and product classes which the the client accesses. The client (createmaze() in in the the example) would interact with the the factory through an an interface/abstract class which can be be implemented by by different factories. Moreover all all the the products (Wall, BombedWall etc.) generated through same method which is is implemented by by different factories, implement the the same interface or or extend the the same abstract class. Charlie Abela CSA1019: Design Patterns 22

23 Abstract Factory Design Pattern Generally the the Abstract Factory is is used used when: A system system should should be be independent of of how how its its products are are created, created, composed or or represented A system system should should be be configured with with one one of of multiple families families of of products A family family of of related related product product objects objects is is designed to to be be used used together together One One wants wants to to provide provide a a class class library library but but wants wants to to reveal reveal just just their their interfaces, not not their their implementation. Charlie Abela CSA1019: Design Patterns 23

24 Abstract Factory Example Applying the the Abstract Factory d.p. d.p. to to the the mazegame example: public abstract class class MazeFactory { public Maze Maze makemaze(); public Wall Wall makewall(); public Room Room makeroom(); public Door Door makedoor(); } Now Now the the createmaze() method of of the the MazeGame class class takes takes a MazeFactory reference as as a parameter: public class class MazeGame { public Maze Maze createmaze(mazefactory f){ f){ Maze Maze maze maze = f.makemaze(); Room Room r1 r1 = f.makeroom(1); Room Room r2 r2 = f.makeroom(2); Door Door door door = f.makedoor(r1, r2); r2); } maze.addroom(r1); maze.addroom(r2); r1.setside(north,f.makewall()); r1.setside(east,door); return maze; maze; Charlie Abela CSA1019: Design Patterns 24

25 Abstract Factory Example (cont) We can easily extend MazeFactory create other factories: to to public class class EnchantedMazeFactory extends MazeFactory{ public Room Room makeroom(int n){ n){ return new new EnchantedRoom(n);} public Wall Wall makewall(){ return new new EnchantedWall();} public Door Door makedoor(room r1, r1, Room Room r2){ r2){ return new new EnchantedDoor(r1, r2);} r2);} } Note that createmaze() can create components from EnchantedMazeFactory or or any implementation of of MazeFactory Charlie Abela CSA1019: Design Patterns 25

26 Abstract Factory Example (cont) Participants AbstractFactory: Declares an an interface for for operations that that create abstract product objects ConcreteFactory: Implements the the operations to to create concrete product objects AbstractProduct: Declares an an interface for for a type type of of product object ConcreteProduct: Defines a product object to to be be created by by the the corresponding concrete factory. Implements the the AbstractProduct interface Client: Uses Uses only only interfaces declared by by AbstractFactory and and AbstractProduct classes In In this example, the the correlations are: AbstractFactory => => MazeFactory ConcreteFactory => => EnchantedMazeFactory (MazeFactory is is also also a ConcreteFactory) AbstractProduct => => MazeComponent ConcreteProduct => => Wall, Wall, Room, Room, Door, Door, EnchantedWall,EnchantedRoom,Enchanted Door Door Client => => MazeGame Charlie Abela CSA1019: Design Patterns 26

27 Singleton Design Pattern (Creational) There exist circumstances when only one instance of of an an object can exist examples are are database connection pools, printer spoolers, window managers, file systems etc. The Singleton design pattern ensures that a class has only one instance. The idea is is that of of encapsulating an an instance of of a class within the the class itself. Any client which would like to to get get a reference to to an an instance invokes a static method of of the the class which returns a reference to to the the instance encapsulated within the the class. public class class Singleton{ private static Singleton instance = null; null; } protected Singleton(){ // // Exists only only to to defeat instantiation. } public static Singleton getinstance(){ if(instance == == null){ instance = new new Singleton(); } return instance; } Charlie Abela CSA1019: Design Patterns 27

28 Singleton Design Pattern Let us us say that there can be only one instance of of the MazeFactory class. public class class MazeFactory { private static MazeFactory m = new new MazeFactory() private MazeFactory(){} public static MazeFactory getinstance(){ return m;} m;} public Maze Maze makemaze() { } { } public Wall Wall makewall() { } } } } Charlie Abela CSA1019: Design Patterns 28

29 Adapter Design Pattern (Structural) Structural d.p. s are are concerned with with how how classes and and objects are are composed to to form form larger structures. The The Adapter d.p. d.p. is is a structural design pattern which is is used used when we we need need to to convert the the interface of of a class class into into another interface which the the client expects. Generally, we we could change the the class class to to conform to to the the required interface, however this this is is not not an an option if if we we do do not not have have the the source code. Even Even if if we we have have the the source code, sometimes it it is is not not practical to to adopt domain-specific interfaces to to have have the the class class integrate with with one one application. The The Adapter design pattern proposes two two different ways ways of of how how to to tackle this: this: By By inheritance (Class Adapter) Define an an adapter class class which subclasses the the given class class and and implements the the required interface By By composition (Object Adapter) The The adapter class class implements the the required interface and and maintains a reference to to an an instance of of the the class, delegating all all the the method invocations. Class adapters are are simpler than than object adapters in in that that they they involve fewer classes and and are are useful if if total total decoupling of of the the client and and Adaptee is is not not needed. Charlie Abela CSA1019: Design Patterns 29

30 Class Adapter Class adapters use use multiple inheritance to to achieve their their goals. The The class class adapter inherits the the interface of of the the client's target. However, it it also also inherits the the interface of of the the Adaptee as as well. well. Since Java Java does does not not support true true multiple inheritance, this this means that that one one of of the the interfaces must must be be inherited from from a Java Java Interface type. type. Note Note that that either or or both both of of the the Target or or Adaptee interfaces could be be a Java Java Interface. The The request to to the the target is is simply rerouted to to the the specific request that that was was inherited from from the the Adaptee interface. Charlie Abela CSA1019: Design Patterns 30

31 Object Adapter Object adapters use use a compositional technique to to adapt one one interface to to another. The The adapter inherits the the target interface that that the the client expects to to see, see, while it it holds an an instance to to the the Adaptee. When the the client calls calls the the request() method on on its its target object (the (the adapter), the the request is is translated into into the the corresponding specific request on on the the Adaptee. Object adapters enable the the client and and the the Adaptee to to be be completely decoupled from from each each other. Only Only the the adapter knows about both both of of them them Charlie Abela CSA1019: Design Patterns 31

32 Adapter Example Consider a drawing editor which manages graphical elements through a Shape Shapesuperclass. Graphical components such such as as PolygonShape, LineShape etc etc are are implemented as as subclasses of of Shape Shape Classes for for elementary geometric shapes are are easy easy to to implement, but but a TextShape subclass which allows for for text text editing could be be rather difficult to to implement -- hence we we might get get an an off-the-shelf TextView component. However this this component was was not not designed to to conform to to our our Shape Shapeinterface. Hence, we we define a TextShape adapter which adapts the the TextView interface to to Shape s. Target domain-specific interface used used by by client Client collaborates with with objects conforming to to Target Adaptee an an existing interface which needs adapting Adapter adapts the the interface of of Adaptee to to Target Charlie Abela CSA1019: Design Patterns 32

33 Adapter Example (cont) shape.request(); Editor Shape Shape: shape void request() void request(){ text.display(); } TextShapeAdapter TextView: text void request() TextView void display() Charlie Abela CSA1019: Design Patterns 33

34 Decorator Design Pattern (Structural) Sometimes it it is is the the case case that that we we want want to to add add responsibilities to to individual objects, rather than than to to an an entire class. A graphical user user interface toolkit, for for instance, should let let you you add add properties like like borders or or behaviour like like scrolling to to a graphical object Rather than than making our our component a subclass of of another class class which puts puts a border around every subclass instance (choice of of border is is static) we we make use use of of the the Decorator design pattern. The The Decorator d.p. d.p. defines a Decorator which conforms to to the the interface of of the the component it it decorates so so that that its its presence is is transparent to to the the component s clients. The The decorator wraps the the component and and forwards requests to to it it performing additional actions before or or after after forwarding. Transparency lets lets you you nest nest decorators recursively. The The Decorator d.p. d.p. varies from from the the Adapter d.p. d.p. in in that that a decorator only only changes an an object s responsibilities, not not its its interface; As As we we have have seen seen an an adapter gives an an object a completely new new interface. Charlie Abela CSA1019: Design Patterns 34

35 Decorator Design Pattern (cont) Motivation Applicability of of the the Decorator: To To add add responsibilities to to individual objects dynamically without affecting other other objects. When extension by by subclassing is is impractical. Sometimes a large large number of of independent extensions are are possible and and would produce an an explosion of of subclasses to to support every combination. Or Or a class class definition may may be be hidden or or otherwise unavailable for for subclassing. Charlie Abela CSA1019: Design Patterns 35

36 Decorator Design Pattern (cont) Charlie Abela CSA1019: Design Patterns 36

37 Decorator D.P. Example The The Structure for for the the Decorator d.p. d.p. includes: Component defines the the interface for for objects that that can can have have responsibilities added to to them them dynamically. ConcreteComponent defines an an object to to which additional responsibilities can can be be attached. Decorator maintains a reference to to a Component Object. ConcreteDecorator adds adds responsibilities to to the the component. Note Note that that Decorator and and all all of of its its subclasses inherit directly from from the the Component interface and and define same same set set of of operations as as Component Charlie Abela CSA1019: Design Patterns 37

38 Decorator D.P. Example The The java.io classes are are based over over this this design pattern. // // Open Open an an InputStream. FileInputStream in in = new new FileInputStream("test.dat"); // // Create a buffered InputStream. BufferedInputStream bin bin = new new BufferedInputStream(in); // // Create a buffered, LineNumerInputStream. LineNumberInputStream lnbin lnbin = new new LineNumberInputStream(bin); Text File for reading FileInputStream BufferedInputStream LineNumberInputStream Charlie Abela CSA1019: Design Patterns 38

39 Observer Design Pattern (Behavioural) The The Observer d.p. d.p. is is a behavioral pattern. Behavioral patterns are are concerned with with algorithms and and assignment of of responsibilities between objects. Behavioral patterns describe not not just just patterns of of objects or or classes but but also also patterns of of communication between them. The The Observer d.p. d.p. defines a one-to-many dependency between objects so so that that when one one object changes state, state, all all its its dependents are are notified and and updated automatically. The The need need for for such such a d.p. d.p. arises from from the the need need to to maintain consistency in in a system which is is partitioned into into a collection of of cooperating, non-tightly coupled, classes. The The key key objects in in this this pattern are are subject and and observer. A subject may may have have any any number of of independent observers. All All observers are are notified whenever the the subject undergoes a change in in state. state. In In Java Java this this design pattern is is used used by by GUI GUI components. Java Java defines events, listener interfaces, event throwing algorithms and and listener registration methods. Charlie Abela CSA1019: Design Patterns 39

40 Observer Design Pattern Motivation Charlie Abela CSA1019: Design Patterns 40

41 Observer D.P. Example The The Observer d.p. d.p. can can be be used used in in these these situations: When When a a change change to to one one object object requires requires changing others, others, (without knowing how how many many objects objects need need to to be be changed) When When an an object object should should be be able able to to notify notify other other objects objects without without making making assumptions about about who who these these objects objects are. are. In In the the diagram Subject Subject :: provides an an interface for for attaching and and detaching Observer objects objects Observer :: defines defines an an updating interface for for objects objects that that should should be be notified notified of of changes changes in in a a subject subject ConcreteSubject sends sends a a notification to to its its observers when when its its state state changes changes ConcreteObserver implements the the Observer updating interface to to keep keep its its state state consistent with with the the subject s. Each subject can have many observers <<Subject>> registerobserver() removeobserver() notifyobserver() observer update() <<Object>> notify each observer of subject's state change ConcreteSubject ConcreteObject registerobserver(){ } removeobserver() { } notifyobserver() { } subject update() { } update() obtains state information from the subject and acts on that state Charlie Abela CSA1019: Design Patterns 41

42 Observer D.P. Example (cont) A typical example of of the the use use of of the the Observer design pattern in in Java Java and and in in particular in in the the Swing API API A JButton has has AbstractButton as as its its superclass. This This has has a lot lot of of add/remove listener methods These These methods allow allow adding adding and and removing of of observers or or listeners public class class ObserverExample{ JFrame frame; public static void void main(string[] args){ ObserverExample ex ex = new new ObserverExample(); ex.go(); } public void void go(){ go(){ frame frame = new new JFrame(); JButton but but = new new JButton( Right or or Wrong? ); but.addactionlistener(new RightListener()); but.addactionlistener(new WrongListener());..... } Charlie Abela CSA1019: Design Patterns 42

43 Observer D.P. Example (cont) class class RightListener implements ActionListener{ public void void actionperformed(actionevent e){ e){ System.out.print( Don t do do it, it, it s it s wrong ); } } class class WrongListener implements ActionListener{ public void void actionperformed(actioneven e){ e){ System.out.print( Come on, on, do do it!! ); } } Charlie Abela CSA1019: Design Patterns 43

44 Strategy Design Pattern (Behavioural) The The Strategy design pattern allows a designer to to define a family of of algorithms and and make them them interchangeable within a class. The The idea idea is is that that of of encapsulating an an algorithm (called a strategy) in in such such a way way that that different implementations of of the the same same algorithm can can be be used. used. The The Strategy design pattern specifies two two interfaces The The Strategy (the (the encapsulation of of the the algorithm) defines defines an an interface which which gives gives abstracted access access to to the the algorithm. This This is is either either an an interface or or an an abstract abstract class class The The Context Context defines defines an an interface which which allows allows algorithm to to extract extract its its context. context. Charlie Abela CSA1019: Design Patterns 44

45 Strategy D.P. Example Situation: A class wants to to decide at at run-time what algorithm it it should use to to sort an an array. Many different sort algorithms are are already available. Solution: Encapsulate the the different sort algorithms using the the Strategy pattern. Charlie Abela CSA1019: Design Patterns 45

46 Strategy D.P. Example 2 Situation: A GUI GUI container object wants to to decide at at run-time what what strategy it it should use use to to layout the the GUI GUI components it it contains. Many different layout strategies are are already available. The The Java Java AWT adopts this this strategy for for its its LayoutManagers. Container <<LayoutManager>> FlowLayout BorderLayout CardLayout Charlie Abela CSA1019: Design Patterns 46

47 References Design Patterns, Elements of of Reusable Object-Oriented Software, by by Gamma, Helm, Johnson and Vlissides, Addison-Wesley, 1997 Head First Design Patterns, Eric Freeman, O Reilly, 2004 Practical UML Inheritance versus composition, Compo.pdf CMSC491D Design Patterns In In Java, by by Bob Tarr, Java Design Patterns at at a Glance, Java design patterns 101, introductory article by by David Gallardo, Charlie Abela CSA1019: Design Patterns 47