Template Method Design Pattern

Template method design pattern is to define an algorithm as skeleton of operations and leave the details to be implemented by the child classes. The overall structure and sequence of the algorithm is preserved by the parent class.

This behavioral design pattern is one of the easiest to understand and implement. This design pattern is used popularly in framework development. This helps to avoid code duplication also.

Template Method Definition

Template method design pattern has two components. An abstract parent class and one or more concrete child classes extending that parent class. The abstract parent class is the template class used to define the algorithmic steps and preserve it across implementations. Child class contains details of the abstract methods.

Key Points on Template Method Design Pattern

• Base abstract class contain complete implementation of an operation(method) and used in the algorithm. In such cases, those methods should be clearly marked as not for implementation by subclasses.
• This design pattern can also be implemented with a base concrete class and all the operations given a default behavior in base class itself.
• The template method in base class should be restricted so that the subclasses does not override it.
• It is better to have lesser number of methods to be implemented by the subclasses and that will help provide an easy implementation.
• Use better naming convention to highlight the methods that should be implemented by the subclasses.
• Template method design pattern uses the inverted control structure as in “Don’t call, we will call you”. The operations defined in subclasses are called by base class from within the template method.
• More care should be taken when defining the Java access modifiers.

UML Class Diagram for Template Method Pattern

Example for Template Method Design Pattern

In the above UML diagram an example is shown. It deals with order processing flow. The OrderProcessTemplate class is an abstract class containing the algorithm skeleton. As shown on note, processOrder() is the method that contains the process steps. We have two subclasses NetOrder and StoreOrder which has the same order processing steps.

So the overall algorithm used to process an order is defined in the base class and used by the subclasses. But the way individual operations are performed vary depending on the subclass.

OrderProcessTemplate.java

package com.javapapers.designpatterns.template;

public abstract class OrderProcessTemplate {
	public boolean isGift;

	public abstract void doSelect();

	public abstract void doPayment();

	public final void giftWrap() {
		System.out.println("Gift wrap done.");
	}

	public abstract void doDelivery();

	public final void processOrder() {
		doSelect();
		doPayment();
		if (isGift) {
			giftWrap();
		}
		doDelivery();
	}
}

NetOrder.java

package com.javapapers.designpatterns.template;

public class NetOrder extends OrderProcessTemplate {

	@Override
	public void doSelect() {
		System.out.println("Item added to online shopping cart,");
		System.out.println("Get gift wrap preference,");
		System.out.println("Get delivery address.");
	}

	@Override
	public void doPayment() {
		System.out.println("Online Payment through Netbanking/Cards.");
	}

	@Override
	public void doDelivery() {
		System.out.println("Ship the item through post to delivery address");
	}

}

StoreOrder.java

package com.javapapers.designpatterns.template;

public class StoreOrder extends OrderProcessTemplate {

	@Override
	public void doSelect() {
		System.out.println("Customer chooses the item from shelf.");
	}

	@Override
	public void doPayment() {
		System.out.println("Pays at counter through cash/POS");
	}

	@Override
	public void doDelivery() {
		System.out.println("Item deliverd to in delivery counter.");
	}

}

TemplateMethodPatternClient.java

package com.javapapers.designpatterns.template;

public class TemplateMethodPatternClient {
	public static void main(String... args) {
		System.out.println("$$$$$$$ NetOrder instance of the Template: $$$$$$$");
		OrderProcessTemplate netOrder = new NetOrder();
		netOrder.processOrder();
		System.out.println("$$$$$$$ StoreOrder instance of the Template: $$$$$$$");
		OrderProcessTemplate storeOrder = new StoreOrder();
		storeOrder.processOrder();
	}
}

Template Method Pattern Output

$$$$$$$ NetOrder instance of the Template: $$$$$$$
Item added to online shopping cart,
Get gift wrap preference,
Get delivery address.
Online Payment through Netbanking/Cards.
Ship the item through post to delivery address
$$$$$$$ StoreOrder instance of the Template: $$$$$$$
Customer chooses the item from shelf.
Pays at counter through cash/POS
Item deliverd to in delivery counter.

Template Method Pattern Example in Java API

Class HttpServlet and it doGet, doPost, doPut,… methods are example of template method pattern usage in Java API.