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

Template Method

Introduction
Template Method- The Pattern

Intent
Motivation
Applicability
Structure
Consequences
Implementation
Implementing a Template Method
Sample Code

Exercises

Doc 5, Template 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 Method Slide # 3

class Account {
   public:
      void virtual Transaction() = 0;
}
class JuniorAccount : public Account {
   public
      void Transaction() { put code here}
}

Doc 5, Template 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 Method Slide # 5

Template Method- The Pattern

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 Method Slide # 6

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 Method Slide # 7

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 Method Slide # 8

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 Method Slide # 9

• Concrete operations
• Concrete AbstractClass 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 Method Slide # 10

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 Method Slide # 11

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 Method Slide # 12

Sample Code

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 Method Slide # 13

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

Doc 5, Template Method Slide # 14

Exercises

Doc 5, Template Method Slide # 15

Previous    visitors since 19-Feb-01    Next