Template Method

Avijeet

Dash, Satyabrata

Dash, Shashidhara

S G

Template Methods lead to an inverted control structure that’s sometimes

referred to as "the Hollywood principle", that is, "Don’t call

us, we’ll call you". This refers to how a parent class calls the

operations of a subclass and not the other way round. Template methods are so

fundamental that they can be found in almost every abstract class.

Intent

Define the skeleton of an algorithm in an operation,

deferring some steps to client subclasses. Template Method lets subclasses

redefine certain steps of an algorithm without changing the algorithm's

structure.

 

In 30 Seconds

The catch here is "how a parent class can enforce an

invariant for its subclasses". Algorithms often have invariant parts

and variant parts. Now, the idea here is to implement all the invariant and

variant parts once in the parent class and let subclasses implement their own

variant parts. The critical thing about the Template method is it fixes the

ordering of the steps of an algorithm.

The step’s implementation can vary depending on the

subclass. Some steps can be implemented in the abstract methods in the parent

class. Some steps can be "Hook" methods, which do nothing in parent

class but may get overridden by subclass. Basically the steps are like primitive

operations some of which must get overridden and some may not. The idea is to

factor and localize the common behavior among subclasses in a Template method

and keep it in the parent class. This pattern is the target of the rafactoring

called "form template method".

Motivation

From an object collaboration angle we have an Abstract class

and concrete classes. The Abstract class has the one and the only Template

method, which calls primitive operations in it. The primitive operations are

abstract methods in the abstract class, which may get overridden in the concrete

class.

 

Template Method is used prominently in frameworks. Each

framework implements the invariant pieces of a domain's architecture, and

defines "placeholders" for all necessary or interesting client

customization options. In so doing, the framework becomes the "center of

the universe", and the client customizations are simply "the third

rock from the sun". This inverted control structure has been affectionately

labeled "the Hollywood principle" - "don't call us, we'll call

you".

 

For example the standard template library, used extensively

in C++ programs, makes use of this pattern. The std::map is a best example for

this. In this template class the library provides the flexibility of redefining

the compare method of the class, which is used inside almost all the operations

of the class. This allows the user to use even the user defined structures as

keys inside the map and he can provide the corresponding comparison method for

that structure.

 

The Template Method defines a skeleton of an algorithm in an

operation, and defers some steps to subclasses. Let us take the example of Loan

accounts, where it is required to calculate the interest on different loan

accounts. The interest rate and the type of the interest (may simple interest or

compound interest) may be different for different types of accounts.






Structure

Example

Here we have an algorithm Calculate Interest defined

in the base class LoanAccount that uses two primitive operations inside

it.

1. GetInterestType
2. GetInterestRate

CalculateInterest is the Template Method. The method

provides the flexibility for the subclasses to decide the type of the interest

that is going to be used, and also the rate of interest rate to be used, which

obviously differs for different loan accounts.






Sample Code

abstract class LoanAccount{
        //the template method — which is not overridden
        public void calculateInterest(){
	      // Get Interest Rate
             double interest=getInterestRate();
             char intType=getInterestType();
             /* Algorithm to calculate interest can be implemented here
        */
             }
	   protected double abstract getInterestRate();
	   protected char abstract getInterestType();
}
class AccountA extends LoanAccount{
	   public double getInterestRate{
		     return 10.0;
	   }
	   public char getInterestType(){
		     //return Simple
		     return ‘s’;
	  }
}
class AccountB extends LoanAccount{
	   public double getInterestRate{
	         return s.0;
	   }
	   public char getInterestType(){
		     //return Compound
		     return ‘c’;
      }
}

// Client class
public class Client{
	  public static void main(String args<>){
           //client knows the kind of subclass to use, and the
           subclass calls the parent       //class’s template method
           LoanAccount account=new AccountA();
		    account.calculateInterest();
	  }
}

Complexities simplified

Template Methods call the following kinds of operations

1. Concrete operations(either on ConcreteClass or on client classes)
2. concrete AbstractClass operations(i.e. operations that are generally
   
   useful to subclasses)
3. primitive operations(i.e. abstract operations). getInterestType() and
   
   getInterestRate() are primitive operations.
4. factory methods.
5. hook operations, which provide default behaviors that subclasses can
   
   extend if necessary.

• There can be any number of templateMethods (calculateInterest() is a
  
  template method in the above example), each of which can call any number of
  
  primitive operations.
• There can be any number of ConcreteClass subclasses of AbstractClass. The
  
  primitive operations are often (but not always) abstract methods of the
  
  AbstractClass, and they should be protected.

The templateMethods are not overridden by subclasses while the

primitive operations are overridden.

Related Patterns

Factory Methods are often called by template methods.

Strategy: Template methods use inheritance to vary part of an algorithm.

Strategy uses delegation to vary the entire algorithm.

(The authors are working as Senior Developers at MindTree

Consulting Pvt. Ltd.)