You are on page 1of 35

Template  Method  Pa.ern     and     Iterator  Pa.


1 CSCI 3132 Summer 2011

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  

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  

  •  Knowledge  of  the  algorithm  and   implementa.   4 .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.Problems  with  the  Solu.on  is  distributed  over  classes.on.

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

         Class  Diagram  for  the  New  Approach   6 .  Prepare  Recipe   7 .

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

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

ern   •  Encapsulates  an  algorithm  by  crea.   •  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.   •  Some  steps  of  the  algorithm  are  concrete   methods  defined  in  the  super  class.   10 .Template  a  template   for  it.   •  The  subclasses  can  redefine  certain  steps  of  the   algorithm  without  changing  the  algorithm’s   structure.

Template  Pa.ern  Structure   11 .

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 .

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

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

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

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

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

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

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

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

size().get(i) }   for(int i=0. ArrayList breakfastItems = pancakeHouseMenu. ++i) { MenuItem menuItem= (MenuItem)  through  the  lunch  items:     21 . MenuItems[] lunchItems = dinerMenu.Original  Itera. i < breakfastItems. I < lunchItems.on   •  Gebng  the  menu  items:     PancakeHouseMenu pancakeHouseMenu= new PancakeHouseMenu()  through  the  breakfast  items:     for(int i=0. DinerMenu dinerMenu = new DinerMenu().getMenuItems(). i++) { MenuItem menuItem = lunchItems[i] }   •  Itera.getMenuItems(): •  Itera.

createIterator().ng  through  the  breakfast  items:     Iterator iterator = }   22 . }   •  Itera. while(iterator.Using  an  Iterator   •  through  the  lunch  items:     Iterator iterator = lunchMenu.createIterator(). while(iterator.hasNext()) { MenuItem menuItem = (MenuItem) { MenuItem menuItem = (MenuItem)iterator.

   Class  Diagram     23 .

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

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

ern:  Structure   26 .Iterator  Pa.

} •  Any  collec. virtual Item CurrentItem() const = 0. virtual bool IsDone() const = 0.Iterator  Pa.on  class  that  wants  to  define  an  iterator  will  define   another  (concrete  iterator)  class  that  inherits  from  this  class   27 .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. protected: Iterator().

on  class  that  wants  to  provide   iterators  will  inherit  from  this  class   28 ..Iterator  pa. //. }   •  Any  collec..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.

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

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). long _current. bool IsDone() const.on  class  that  wants  to  define  an  iterator  will  define   another  (concrete  iterator)  class  that  inherits  from  30 this  class   . } •  Any  collec.Iterator  pa. Item CurrentItem() const. void Next(). private: const List<Item>* _list. void First().

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

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

Using  the  Iterator   void PrintEmpolyees (Iterator<Emplyee*>& i){ for( i. } List<Employee*>* employees. ReverseListIterator<Employee*> backward(employees). 33 .First(). !i. // … ListIterator<Employee*> forward(employees).Next()) i. i. PrintEmployees(forward). PrintEmplyees(backward).CurrentItem() -> Print().IsDone().

 in-­‐order.Iterator  Pa.ern   Consequences   •  An  iterator  supports   34 .ple  iterators  can  be  working  at  any  given  .   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.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.

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