Template Design Pattern

What is Template Design Pattern?

An abstract class defines various methods and has one non-overridden method which calls the various methods.

also read:

Wikipedia Says:
A template method defines the program skeleton of an aligorithm.The aligorithm itself is made abstract,and the subclasses override the abstract methods to provide concrete behavior.First a class is created that provides the basic steps of an aligorithm design.These steps are implemented using abstract methods.Later on subclasses change the abstract methods to implement real actions.Thus the general aligorithm is saved in one place but the concrete steps may be changed by the subclasses.
Non-Abstract Methods are completly controlled by the Template Method.In contrast the template method need not be changed and is not an abstract operation and thus may guarentee required steps before and after the abstract operations.Thus the template method is invoked and as a consequence the non-abstract methods and abstract methods are called in the correct sequence.

Intent: Define the skeleton of an aligorithm in an operation,deferring some steps to subclasses.Template methods lets subclasses redefine certain steps of an aligorithm without changing the aligorithm structure .[DesignPatterns, p. 325]

Motivation:
Sometimes we want to specify the order of operations that a method uses,but allow subclasses to provide their own implementation of some of these operations.When ever we see two methods in subclasses,it makes sense to bring the methods together into a superclass method.

Applicability:
Use the Template method pattern:

  • To implement the invariant parts of an aligorithm once and leave it up to subclasses to implement the behavior that can vary.
  • To localize common behavior among subclasses and place it in a common class(in this case a superclass) to avoid code duplication.This is a classic example of “code refactoring”.
  • To control how subclasses extend superclass operations.You can define a template method that calls “hook” operations at specific points,there by permitting extensions only at that point.

THE TEMPLATE METHOD IS A FUNDAMENTAL TECHNIQUE FOR CODE REUSE

Problem:
Two different component have significant similarities,but demonstrate no reuse of common interface or implementation.If a change common to both components becomes necessary,duplicate effort must be expended.

Discussion:
The component designer decides which steps of an aligorithm are invariant(or standard) and which are variant(or customizable).The invariant steps are implemented in an abstract base class,while the variant steps are either given a default implementation or no implementation at all.The “variant” steps represent “hooks”,or “placeholders” that can or must be supplied by the component’s client in a concrete derived class.
The component designer mandates the required steps of an aligorithm,and the ordering of the steps,but allow the component client to extend or replace some number of steps.
Template methods are prominently used in frameworks.Each framework implements the invariant pieces of domain’s architecture,and defines “placeholders” for all necessary or interesting client customization options.The inverted control structure has been affectionately labelled “the hollywood principle” – Don’t call us we will call you.

Usage:
The template method is used to:

  • Let subclasses implement behavior that can vary.
  • Avoid duplication in the code.We look for general code in the aligorithm and implement variants in the subclasses.
  • Control at what point(s) subclassing is allowed.

Implementation Issues:

  • Operations which must be overridden by subclasses should be made abstract.
  • If the template method itself should not be overidden by subclasses it should be made final.
  • To allow a subclass to insert code at a specific spot in the operation of the aligorithm,insert “hook” operations into the template method.These hook operations may do nothing by default.
  • Try to minimize the number of operations that a subclass must override.
  • In a template method parent class calls the operations of a subclass and not the other way round.

Example:
The template method defines a skeleton of an aligorithm in an operation and defers some steps to subclasses.Home Builders use the template method when developing a new subdivision.A typical subdivision consits of a limited number of floor plans with diff variations available for each.Within a floor plan, the foundation, framing, plumbing, and wiring will be identical for each house. Variation is introduced in the later stages of construction to produce a wider variety of models. [Michael Duell, “Non-software examples of software design patterns”, Object Magazine, Jul 97, p54]

Template method pattern could be refactored using an interface that explicitly signals the methods requested to subclasses and also the state needed by them from the abstract class.

Rules of Thumb:
Strategy is like Template Method except in its granularity.[Coplien, C++ Report, Mar 96, p88]
Template method uses inheritance to vary part of an aligorithm.Strategy uses delegation to vary the entire aligorithm. [GOF, p330]

Also Alex has a good explanation of why he hates Template Pattern.Even i do agree to some extent.

Below example gives an implementation of Template Design Pattern.

package patterns;

abstract class TitleInfo {
 private String titleName;

 // The Template Method.
 // Calls the concrete class methods,is not overridden

 public final String processTitleInfo() {
  StringBuffer titleInfo=new StringBuffer();
  titleInfo.append(this.getTitleBlurb());
  titleInfo.append(this.getDvdEncodingRegionInfo());
  return titleInfo.toString();
 }

 public final void setTitleName(String titleNameIn) {
  this.titleName=titleNameIn;
 }

 public final String getTitleName() {
  return this.titleName;
 }

 public abstract String getTitleBlurb();

 public String getDvdEncodingRegionInfo() {
  return " ";
 }

}

class DvdTitleInfo extends TitleInfo {
 String star;
 char encodingRegion;

 public DvdTitleInfo(String titleName,String star,char encodingRegion) {
  this.setTitleName(titleName);
  this.setStar(star);
  this.setEncodingRegion(encodingRegion);
 }

 public char getEncodingRegion() {
  return encodingRegion;
 }

 public void setEncodingRegion(char encodingRegion) {
  this.encodingRegion = encodingRegion;
 }

 public String getStar() {
  return star;
 }

 public void setStar(String star) {
  this.star = star;
 }

 public String getTitleBlurb() {
  return ("DVD: " + this.getTitleName() + ", starring " + this.getStar());
 }

 public String getDvdEncodingRegionInfo() {
        return (", encoding region: " + this.getEncodingRegion());
    }
}

class BookTitleInfo extends TitleInfo {
 private String author;

 public BookTitleInfo(String titleName,String author) {
  this.setAuthor(author);
  this.setTitleName(titleName);
 }

 public String getAuthor() {
  return author;
 }

 public void setAuthor(String author) {
  this.author = author;
 }

 public String getTitleBlurb() {
  return ("Book: " + this.getTitleName() + ", Author: " + this.getAuthor());
 }
}

public class TemplatePatternDemo {

 public static void main(String[] args) {
  TitleInfo bladeRunner=new DvdTitleInfo("Blade Runner","Harrison Ford",'1');
  TitleInfo electricSheep=new BookTitleInfo("Do Androids Dream of Electric Sheep?","Philip");

  System.out.println(" ");
  System.out.println("Testing bladeRunner" + bladeRunner.processTitleInfo());
  System.out.println("Testing electricSheep" + electricSheep.processTitleInfo());
 }
}

Comments

comments

About Krishna Srinivasan

He is Founder and Chief Editor of JavaBeat. He has more than 8+ years of experience on developing Web applications. He writes about Spring, DOJO, JSF, Hibernate and many other emerging technologies in this blog.

Comments

  1. webdesignbizzz says:

    It is my great pleasure to visit your website and to enjoy your excellent post here. It's been very useful for us and i am sure others as well..Thanks for this great posting i'll keep in touch with this post …Template Design

Trackbacks

  1. […] Template Method : This pattern defines the program skeleton of an algorithm in a method, called template method, which defers some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm’s structure. […]

Speak Your Mind

*