Template Method Design Pattern in Java

浏览数：18 / 时间：2015年06月08日

Template Method is a behavioral design pattern and it’s used to create a method stub and deferring some of the steps of implementation to the subclasses.Template method defines the steps to execute an algorithm and it can provide default implementation that might be common for all or some of the subclasses.

Let’s understand this pattern with an example, suppose we want to provide an algorithm to build a house. The steps need to be performed to build a house are – building foundation, building pillars, building walls and windows. The important point is that the we can’t change the order of execution because we can’t build windows before building the foundation. So in this case we can create a template method that will use different methods to build the house.

Now building the foundation for a house is same for all type of houses, whether its a wooden house or a glass house. So we can provide base implementation for this, if subclasses want to override this method, they can but mostly it’s common for all the types of houses.

To make sure that subclasses don’t override the template method, we should make it final.

Template Method Abstract Class

Since we want some of the methods to be implemented by subclasses, we have to make our base class as abstract class.

HouseTemplate.java

01 package com.journaldev.design.template;
02  
03 public abstract class HouseTemplate {
04  
05     //template method, final so subclasses can‘t override
06     public final void buildHouse(){
07         buildFoundation();
08         buildPillars();
09         buildWalls();
10         buildWindows();
11         System.out.println("House is built.");
12     }
13  
14     //default implementation
15     private void buildWindows() {
16         System.out.println("Building Glass Windows");
17     }
18  
19     //methods to be implemented by subclasses
20     public abstract void buildWalls();
21     public abstract void buildPillars();
22  
23     private void buildFoundation() {
24         System.out.println("Building foundation with cement,iron rods and sand");
25     }
26 }

buildHouse() is the template method and defines the order of execution for performing several steps.

Template Method Concrete Classes

We can have different type of houses, such as Wooden House and Glass House.

WoodenHouse.java

01 package com.journaldev.design.template;
02  
03 public class WoodenHouse extends HouseTemplate {
04  
05     @Override
06     public void buildWalls() {
07         System.out.println("Building Wooden Walls");
08     }
09  
10     @Override
11     public void buildPillars() {
12         System.out.println("Building Pillars with Wood coating");
13     }
14  
15 }

We could have overridden other methods also, but for simplicity I am not doing that.

GlassHouse.java

01 package com.journaldev.design.template;
02  
03 public class GlassHouse extends HouseTemplate {
04  
05     @Override
06     public void buildWalls() {
07         System.out.println("Building Glass Walls");
08     }
09  
10     @Override
11     public void buildPillars() {
12         System.out.println("Building Pillars with glass coating");
13     }
14  
15 }

Template Method Pattern Client

Let’s test our template method pattern example with a test program.

HousingClient.java

01 package com.journaldev.design.template;
02  
03 public class HousingClient {
04  
05     public static void main(String[] args) {
06  
07         HouseTemplate houseType = new WoodenHouse();
08  
09         //using template method
10         houseType.buildHouse();
11         System.out.println("************");
12  
13         houseType = new GlassHouse();
14  
15         houseType.buildHouse();
16     }
17  
18 }

Notice that client is invoking the template method of base class and depending of implementation of different steps, it’s using some of the methods from base class and some of them from subclass.

Output of the above program is:

01 Building foundation with cement,iron rods and sand
02 Building Pillars with Wood coating
03 Building Wooden Walls
04 Building Glass Windows
05 House is built.
06 ************
07 Building foundation with cement,iron rods and sand
08 Building Pillars with glass coating
09 Building Glass Walls
10 Building Glass Windows
11 House is built.

Template Method Class Diagram

Template Method Pattern in JDK

  • All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer.
  • All non-abstract methods of java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap.

Important Points

  • Template method should consists of certain steps whose order is fixed and for some of the methods, implementation differs from base class to subclass. Template method should be final.
  • Most of the times, subclasses calls methods from super class but in template pattern, superclass template method calls methods from subclasses, this is known as Hollywood Principle – “don’t call us, we’ll call you.”.
  • Methods in base class with default implementation are referred as Hooks and they are intended to be overridden by subclasses, if you want some of the methods to be not overridden, you can make them final, for example in our case we can make buildFoundation() method final because if we don’t want subclasses to override it.

Thats all for template method pattern implementation in java, I hope you liked it.
 

Reference: Template Method Design Pattern in Java from our JCG partner Pankaj Kumar at the Developer Recipes blog.

You might also like:

Template Method Design Pattern in Java,古老的榕树,5-wow.com

郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

标签： 编程语言 Java C C# Javascript js Python Ruby Spring 程序 VB

相关文章

随机文章

您可能还喜欢

您可能还喜欢