Template Method Pa.ern and Iterator Pa.ern

Transcription

1 Template Method Pa.ern and Iterator Pa.ern CSCI 3132 Summer

2 Template Method (Behavioral) Intent Define the skeleton of an algorithm in an opera;on, deferring some steps to subclasses Applicability To implement invariant aspects of an algorithm once and let subclasses define variant parts To localize common behavior in a class to increase code reuse To control subclass extensions 2

3 Example: StarBuzz Coffee Recipe Boil some water Brew coffee in boiling water Pour coffee in cup add sugar and milk Tea Recipe Boil some water Steep tea in boiling water Pour tea in cup Add lemon Suppose you are required to implement a system to maintain this 3

4 Problems with the Solu;on Code is duplicated across the classes code changes would have to be made in more than one place. Adding a new beverage would result in further duplica;on. Knowledge of the algorithm and implementa;on is distributed over classes. 4

5 More General Approach Both subclasses inherit a general algorithm. Some methods in the algorithm are concrete, i.e. methods that perform the same ac;ons for all subclasses. Other methods in the algorithm are abstract, i.e. methods that perform class- specific ac;ons. 5

6 Class Diagram for the New Approach 6

7 Abstrac;ng Prepare Recipe 7

8 Advantages of the New Approach A single class protects and controls the algorithm, namely, CaffeineBeverage. The superclass facilitates reuse of methods. Code changes will occur in only one place. Other beverages can be easily added. 8

9 This is the Template Method Pa.ern The preparerecipe() method implements the template pa.ern. This method serves as a template for an algorithm, namely that for making a caffeinated beverage. In the template each step is represented by a method. Some methods are implemented in the superclass. Other method must be implemented by the subclass and are declared abstract. The template pa.ern defines the steps of an algorithm and allows the subclasses to implement one or more of the steps. 9

10 Template Pa.ern Encapsulates an algorithm by crea;ng a template for it. Defines the skeleton of an algorithm as a set of steps. Some methods of the algorithm have to be implemented by the subclasses these are abstract methods in the super class. The subclasses can redefine certain steps of the algorithm without changing the algorithm s structure. Some steps of the algorithm are concrete methods defined in the super class. 10

11 Template Pa.ern Structure 11

12 Terminology Hook methods: placeholders for the behaviour to be implemented by subclasses Template methods: methods containing hook methods Hot spots: changeable behaviours of generic classes represented by hook methods Frozen spots: fixed behaviours of generic classes represented by template methods AbstractClass templatemethod() hookmethod1() hookmethod2() hookmethod1() hookmethod2() ConcreteClass hookmethod1() hookmethod2() 12

13 Using Hooks We want to minimize the number of abstract methods used. Thus, the steps of the algorithm should not be too granular. However, less granularity means less flexibility. Hooks are methods which can be overridden by subclasses, however this is op;onal. Example: Suppose the customer is given an op;on as to whether they would like condiments or not. 13

14 Why Hooks The number of abstract methods used must be minimized. Enables a subclass to implement an op;onal part of an algorithm. Enables a subclass to react to a step in the template method. Enables the subclass to make a decision for the abstract class. 14

15 Hollywood Principle The template pa.ern follows the hollywood principle. Principle: Don t call us, we will call you. Low- level components are ac;vated by high- level components. A low- level component never calls a high- level component. In the template pa.ern the abstract class is the high- level component and the concrete classes the low- level components. 15

16 Template Summary Design Principle: Don t call us we ll call you. Template pa.ern defines steps of an algorithm. Subclasses cannot change the algorithm. Facilitates code reuse. Similar to the strategy pa.ern, but different! 16

17 Design Principle If collec;ons have to manage themselves as well as itera;on of the collec;on this gives the class two responsibili;es instead of one. More than one responsibility means more than one area of change. Thus, each class should be restricted to a single responsibility. Single responsibility: A class should have only one reason to change. Find what varies and encapsulate it. 17

18 Iterator design pa.ern O]en you may have to move through a collec;on Tree (splay, AVL, binary, red- black, etc.), linked list, array, hash table, dic;onary, etc. If it s an array or vector, then this is easy But hard if it s a more complicated data structure Hash table, dic;onary, etc. The code doing the itera;on should not have to know the details of the data structure being used This pa.ern answers the ques;on: How do you provide a standard interface for moving through a collec;on of objects whose data structure is unknown? 18

19 Problems Suppose we are required to print every item on two menus (dinner menu and pancake menu) that stored in different structures. Two loops will be needed instead of one. If a third restaurant is included, three loops will be needed. Design principles that would be violated: Coding to implementa;on rather than interface The program implemen;ng the joint print_menu() needs to know the internal structure of the collec;on of each set of menu items. Duplica;on of code 19

20 Solu;on Encapsulate what varies, i.e. encapsulate the itera;on. An iterator is used for this purpose. The DinerMenu class and the PancakeMenu class need to implement a method called createiterator (). The Iterator is used to iterate through each collec;on without knowing its type (i.e. Array or ArrayList) 20

21 Original Itera;on Gebng the menu items: PancakeHouseMenu pancakehousemenu= new PancakeHouseMenu(); ArrayList breakfastitems = pancakehousemenu.getmenuitems(); DinerMenu dinermenu = new DinerMenu(); MenuItems[] lunchitems = dinermenu.getmenuitems(): Itera;ng through the breakfast items: for(int i=0; i < breakfastitems.size(); ++i) { MenuItem menuitem= (MenuItem) breakfastitems.get(i) } Itera;ng through the lunch items: for(int i=0; I < lunchitems.length; i++) { MenuItem menuitem = lunchitems[i] } 21

22 Using an Iterator Itera;ng through the breakfast items: Iterator iterator = breakfastmenu.createiterator(); while(iterator.hasnext()) { MenuItem menuitem = (MenuItem)iterator.next(); } Itera;ng through the lunch items: Iterator iterator = lunchmenu.createiterator(); while(iterator.hasnext()) { MenuItem menuitem = (MenuItem)iterator.next(); } 22

23 Class Diagram 23

24 Iterator Pa.ern Defini;on Provides a way to access elements of a collec;on object sequen;ally without exposing its underlying representa;on. The iterator object takes the responsibility of traversing a collec;on away from collec;on object. This simplifies the collec;on interface and implementa;on. Allows the traversal of the elements of a collec;on without exposing the underlying implementa;on. 24

25 Iterator Pa.ern The key par;cipants in this pa.ern are: The Iterator, which provides an (virtual) interface for moving through a collec;on of things The Aggregate, which defines the (virtual) interface for a collec;on that provides iterators The ConcreteIterator, which is the class that inherits/extends/ implements the Iterator The ConcreteAggregate, which is the class that inherits/extends/ implements the Aggregate This pa.ern is also known as cursor Iterator is a pa.ern that shows why we would use mul;ple inheritance 25

26 Iterator Pa.ern: Structure 26

27 Iterator Pa.ern: class Iterator We use an abstract C++ class to define the Iterator: template <class Item> class Iterator { public: virtual void First() = 0; virtual void Next() = 0; virtual bool IsDone() const = 0; virtual Item CurrentItem() const = 0; protected: Iterator(); } Any collec;on class that wants to define an iterator will define another (concrete iterator) class that inherits from this class 27

28 Iterator pa.ern: class AbstractAggregate We use an abstract C++ class to define the AbstractAggregate: template <class Item> class AbstractAggregate { public: } virtual Iterator<Item>* CreateIterator() const = 0; //... Any collec;on class that wants to provide iterators will inherit from this class 28

29 Iterator pa.ern: class List We use a sample C++ class to define a collec;on class (List): template <class Item> class List : public AbstractAggregate { public: List (long size = DEFAULT_LIST_CAPACITY); long Count() const; Item& Get (long index) const; //... } // and the method to provide the iterator... Obviously, this class could be a hash table, dic;onary, tree, etc. 29

30 Iterator pa.ern: class ListIterator We use an abstract C++ class to define the Iterator: template <class Item> class ListIterator : public Iterator<Item> { public: ListIterator (const List<Item>* alist); void First(); void Next(); bool IsDone() const; Item CurrentItem() const; private: const List<Item>* _list; long _current; } Any collec;on class that wants to define an iterator will define 30 another (concrete iterator) class that inherits from this class

31 Iterator pa.ern: class ListIterator cont d template <class Item> ListIterator<Item>::ListIterator ( const List<Item>* alist ) : _list(alist), _current(0) { } template <class Item> void ListIterator<Item>::First() { _current = 0; } template <class Item> void ListIterator<Item>::Next() { _current++; } 31

32 Iterator pa.ern: class ListIterator cont d template <class Item> void ListIterator<Item>::IsDone() const { return _current >= _list->count(); } template <class Item> void ListIterator<Item>::CurrentItem() const { if (IsDone()) throw IteratorOutOfBounds; return _list->get(_current); } 32

33 Using the Iterator void PrintEmpolyees (Iterator<Emplyee*>& i){ for( i.first();!i.isdone(); i.next()) i.currentitem() -> Print(); } List<Employee*>* employees; // ListIterator<Employee*> forward(employees); ReverseListIterator<Employee*> backward(employees); PrintEmployees(forward); PrintEmplyees(backward); 33

34 Iterator Pa.ern Consequences An iterator supports varia;ons in transversal of an aggregate The List class can provide one that iterates forward or backward Moving through a tree can be done in pre- order, in- order, or post- order Iterators support the aggregate interface As it doesn t have to define similar methods More than one transversal can be moving through an aggregate Mul;ple iterators can be working at any given ;me 34

35 Extra: 3D generic world in C++ STL DATA STRUCTURES ALGORITHMS ITERATORS 35