Template Method

Pattern Properties

Type: Behavioral

Level: Object

Purpose

To provide a method that allows subclasses to override parts of the method without rewriting it.

Introduction

When working with projects, you frequently need to estimate the expense involved in performing a certain task or producing a deliverable. The Personal Information Manager uses a number of classes to represent its projects. At a minimum, the Task and Deliverable classes would be used to represent project elements. As a project grew more complex, you might create additional classes like Project or DependentTask to satisfy more sophisticated modeling needs.

While it is possible to create a getCostEstimate method for each of the classes, such an approach involves a lot of code duplication. As the number of classes increases, it becomes more and more difficult to maintain the code in all of the project classes.

A better approach is to group all of the project-related classes under a superclass, and define the method getCostEstimate there. But what would you do if parts of the getCostEstimate method depended on information that was specific to each of the Project classes? What if the Task had a different way of calculating hours from the Deliverable?

In that case, define getCostEstimate so that it calls an abstract method, getTimeRequired, and allows the Task and Deliverable classes to define the method as appropriate. This approach, called the Template Method, provides the benefits of code reusability, while still allowing classes to modify certain parts of the behavior to meet their needs.

Applicability

Use the Template Method pattern:

To provide a skeleton structure for a method, allowing subclasses to redefine specific parts of the method.

To centralize pieces of a method that are defined in all subtypes of a class, but which always have a small difference in each subclass.

To control which operations subclasses are required to override.

Description

When you are building complex class hierarchies for your application, code is often duplicated at several places. This is undesirable, since you want to reuse as much code as you can. Refactoring your code so that the common methods are in a superclass is a step in the right direction. The problem is that sometimes an operation that has been refactored relies on specific information that is only available in a subclass. Because of this, developers often decide not to refactor and accept the duplicate code in multiple subclasses.

When many methods in related classes have a similar structure, the Template Method can help. First, determine which parts of the method are similar. These parts should be centralized in the superclass, while the other operations should remain in the subclasses.

The newly defined template method contains the structure of the operation. For each part of the operation that can vary, an abstract method is defined in the superclass. Subclasses override these methods to provide their own implementation. When the template method is called on a subclass, the code in the superclass is executed.

When you make the template method in the superclass final, subclasses are limited in what parts of their superclass they can override.

93