CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2004 Template & Factory Method
	Previous    Lecture Notes Index    Next     © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 03-Feb-04

Doc 5, Template & Factory Method Slide # 2

Template Method

Introduction

class Account {
   public:   
      void virtual Transaction(float amount) 
            { balance += amount;}
      Account(char* customerName, float InitialDeposit = 0);
   protected:
      char* name;
      float balance;
}

class JuniorAccount : public Account {
   public:   void Transaction(float amount) {//  put code here}
}

class SavingsAccount : public Account {
   public:   void Transaction(float amount) {//  put code here}
}

Account* createNewAccount()
{
   // code to query customer and determine what type of
   // account to create
};

main() {
   Account*  customer;
   customer = createNewAccount();
   customer->Transaction(amount);
}

Doc 5, Template & Factory Method Slide # 3

class Account {
   public:
      void virtual Transaction() = 0;
}

class JuniorAccount : public Account {
   public
      void Transaction() { put code here}
}

Doc 5, Template & Factory Method Slide # 4

class Account {
   public:   
      void Transaction(float amount);
      void virtual TransactionSubpartA();
      void virtual TransactionSubpartB();
      void virtual TransactionSubpartC();
}

void Account::Transaction(float amount)  {
   TransactionSubpartA();      TransactionSubpartB();   
   TransactionSubpartC();      // EvenMoreCode;
}

class JuniorAccount : public Account {
   public:      void virtual TransactionSubpartA(); }

class SavingsAccount : public Account {
   public:      void virtual TransactionSubpartC(); }

Account*  customer;
customer = createNewAccount();
customer->Transaction(amount);

Doc 5, Template & Factory Method Slide # 5

Intent

Motivation

void Application::OpenDocument (const char* name ) {
   if (!CanNotOpenDocument (name)) {
      return;
   }

   Document* doc = DoCreateDocument();

   if (doc) {
      _docs->AddDocument( doc);
      AboutToOpenDocument( doc);
      Doc->Open();
      Doc->DoRead();
   }
}
Doc 5, Template & Factory Method Slide # 6

Object>>printString
   | aStream |
   aStream := WriteStream on: (String new: 16).
   self printOn: aStream.
   ^aStream contents

Object>>printOn: aStream
   | title |
   title := self class printString.
   aStream nextPutAll:
         ((title at: 1) isVowel ifTrue: ['an '] ifFalse: ['a ']).
   aStream nextPutAll: title

Doc 5, Template & Factory Method Slide # 7

collect:, detect:, do:, inject:into:, reject:, select:

Collection>>collect: aBlock  
   | newCollection |
   newCollection := self species new.
   self do: [:each | newCollection add: (aBlock value: each)].
   ^newCollection

Collection>>do: aBlock 
   self subclassResponsibility

Collection>>inject: thisValue into: binaryBlock 
   | nextValue |
   nextValue := thisValue.
   self do: [:each | nextValue := binaryBlock value: nextValue value: each].
   ^nextValue

Collection>>reject: aBlock 
   ^self select: [:element | (aBlock value: element) == false]

Collection>>select: aBlock 
   | newCollection |
   newCollection := self species new.
   self do: [:each | (aBlock value: each) ifTrue: [newCollection add: each]].
   ^newCollection

species, do:, add:

Doc 5, Template & Factory Method Slide # 8

Applicability

• To implement the invariant parts of an algorithm once.

Subclasses implement behavior that can vary

• When common behavior among subclasses should be factored and localized in a common class to avoid code duplication

Template method defines hook operations

Subclasses can only extend these hook operations

Doc 5, Template & Factory Method Slide # 9

Structure

• AbstractClass

Defines abstract primitive operations that concrete subclasses define to implement steps of an algorithm

Implements a template method defining the skeleton of an algorithm

• ConcreteClass

Implements the primitive operations

Different subclasses can implement algorithm details differently

Doc 5, Template & Factory Method Slide # 10

Consequences

Parent class calls subclass methods

Java's paint method is a primitive operation called by a parent method

Beginning Java programs don't understand how the following works:

   import  java.awt.*;
   class  HelloApplication  extends  Frame 
      {
      public  void  paint(  Graphics  display  )
         {
         int startX  =  30;
         int startY  =  40;
         display.drawString(  "Hello World", startX, startY  );
         }
      }

Doc 5, Template & Factory Method Slide # 11

• Concrete operations
• Primitive operations - must be overridden
• Factory methods
• Hook operations

Methods called in Template method and have default implementation in AbstractClass

Provide default behavior that subclasses can extend

Smalltalk's printOn: aStream is a hook operation

• Must overridden
• Can be overridden
• Can not be overridden

Doc 5, Template & Factory Method Slide # 12

Implementation

• Primitive operations can be made protected so can only be called by subclasses

• Template methods should not be overridden - make nonvirtual

• Some frameworks indicate primitive methods with special prefixes

• MacApp use the prefix "Do"

Doc 5, Template & Factory Method Slide # 13

Implementing a Template Method [1]

• Simple implementation

Implement all of the code in one method

The large method you get will become the template method

• Break into steps

Use comments to break the method into logical steps

One comment per step

• Make step methods

Implement separate method for each of the steps

• Call the step methods

Rewrite the template method to call the step methods

• Repeat above steps

Repeat the above steps on each of the step methods

Continue until:

All steps in each method are at the same level of generality

All constants are factored into their own methods

Doc 5, Template & Factory Method Slide # 14

Constant Methods

public class Foo {
   Bar field;
   
   public Bar getField() {
      if (field == null)
         field = new Bar( 10);
      return field;
   }
}

   public Bar getField() {
      if (field == null)
         field = defaultField();
      return field;
   }
   protected Bar defaultField() {
      return new Bar( 10);
   }

Doc 5, Template & Factory Method Slide # 15

   public Foo() {
      field := defaultField();
   }

Doc 5, Template & Factory Method Slide # 16

Factory Method

Doc 5, Template & Factory Method Slide # 17

class MazeGame
   {
   
   public Maze createMaze()
      {
      Maze aMaze = new Maze();
      
      Room r1 = new Room( 1 );
      Room r2 = new Room( 2 );
      Door theDoor = new Door( r1, r2);
      
      aMaze.addRoom( r1 );
      aMaze.addRoom( r2 );
      
      etc.
      
      return aMaze;
      }
   }

Doc 5, Template & Factory Method Slide # 18

class BombedMazeGame extends MazeGame
   {
   
   public Maze createMaze()
      {
      Maze aMaze = new Maze();
      
      Room r1 = new RoomWithABomb( 1 );
      Room r2 = new RoomWithABomb( 2 );
      Door theDoor = new Door( r1, r2);
      
      aMaze.addRoom( r1 );
      aMaze.addRoom( r2 );
      
      etc.

Doc 5, Template & Factory Method Slide # 19

class MazeGame
   {
   
   public Maze makeMaze() { return new Maze(); }
   public Room makeRoom(int n ) { return new Room( n ); }
   public Wall makeWall() { return new Wall(); }
   public Door makeDoor() { return new Door(); }
      
   public Maze CreateMaze()
      {
      Maze aMaze = makeMaze();
      
      Room r1 = makeRoom( 1 );
      Room r2 = makeRoom( 2 );
      Door theDoor = makeDoor( r1, r2);
      
      aMaze.addRoom( r1 );
      aMaze.addRoom( r2 );
      
      etc
      
      return aMaze;
      }
   }

Doc 5, Template & Factory Method Slide # 20

class BombedMazeGame extends MazeGame
   {
   
   public Room makeRoom(int n ) 
      { 
      return new RoomWithABomb( n ); 
      }
      
   public Wall makeWall() 
      { 
      return new BombedWall(); 
      }

Doc 5, Template & Factory Method Slide # 21

Applicability

• A class can't anticipate the class of objects it must create

• A class wants its subclasses to specify the objects it creates

• You want to localize the knowledge of which help classes is used in a class

Doc 5, Template & Factory Method Slide # 22

Consequences

• Eliminates need to hard code specific classes in code

• Requires subclassing to vary types used

• Provides hooks for subclasses

• Connects Parallel class hierarchies

Doc 5, Template & Factory Method Slide # 23

Implementation

Two Major Varieties

• Top level Factory method is in an abstract class

   abstract class MazeGame
      {
      public Maze makeMaze();
      public Room makeRoom(int n );
      public Wall makeWall();
      public Door makeDoor();
      etc.
      }
      
   class MazeGame
      {
      public:
         virtual Maze* makeMaze() = 0;
         virtual Room* makeRoom(int n ) = 0;
         virtual Wall* makeWall() = 0;
         virtual Door* makeDoor() = 0;

• Top level Factory method is in a concrete class

See examples on previous slides

Doc 5, Template & Factory Method Slide # 24

Parameterized Factory Methods

class Hershey 
   {
   
   public Candy makeChocolateStuff( CandyType id )
      {
      if ( id == MarsBars ) return new MarsBars();
      if ( id == M&Ms ) return new M&Ms();
      if ( id == SpecialRich ) return new SpecialRich();
      
      return new PureChocolate();
      }

class GenericBrand extends Hershey
   {
   public Candy makeChocolateStuff( CandyType id )
      {
      if ( id == M&Ms ) return new Flupps();
      if ( id == Milk ) return new MilkChocolate();
      return super.makeChocolateStuff();
      }
   }
   

Doc 5, Template & Factory Method Slide # 25

C++ Templates to Avoid Subclassing

template <class ChocolateType>
class Hershey 
   {
   public:
      virtual Candy* makeChocolateStuff( );
   }
   
template <class ChocolateType>
Candy* Hershey<ChocolateType>::makeChocolateStuff( )
   {
   return new ChocolateType;
   }
   
Hershey<SpecialRich> theBest;

Doc 5, Template & Factory Method Slide # 26

class Hershey 
   {
   private String chocolateType;
   
   public Hershey( String chocolate )
      {
      chocolateType = chocolate;
      }
   
   public Candy makeChocolateStuff( )
      {
      Class candyClass =  Class.forName( chocolateType );
      return (Candy) candyClass.newInstance();
      }
   
Hershey theBest = new Heshsey( "SpecialRich" );

Doc 5, Template & Factory Method Slide # 27

class CandyStore
   {
   Hershey supplier;
   public restock()
      {
      blah
   
      if ( chocolateStock.amount() < 10 )
         {
         chocolateStock.add( 
            supplier.makeChocolateStuff() );
         }
   
   blah

Doc 5, Template & Factory Method Slide # 28

Exercises

Doc 5, Template & Factory Method Slide # 29

Previous    visitors since 03-Feb-04    Next