Template Method Pattern

Introduction

The Template Method pattern is a behavioral design pattern that defines the skeleton of an algorithm in a method, deferring some steps to subclasses. This pattern allows subclasses to redefine certain steps of an algorithm without changing its structure. It is particularly useful when you want to ensure a consistent process flow while allowing flexibility in specific parts of the process.

Concept

The Template Method pattern involves two main components:

1. Abstract Class: This class defines the skeleton of the algorithm, including abstract methods that must be implemented by subclasses.
2. Concrete Classes: These classes implement the abstract methods defined in the abstract class.

The key idea is to define a template method that outlines the steps of an algorithm and delegates some of these steps to concrete methods that can be overridden by subclasses.

Examples

Let's illustrate the Template Method pattern with a practical example. Suppose we are developing a software system for different types of document processing, such as PDF and Word documents. We want to ensure that each document type follows a consistent processing flow but allows specific details to vary.

Step 1: Define the Abstract Class

First, we define an abstract class DocumentProcessor that outlines the general steps of document processing:

1abstract class DocumentProcessor {
2  // Template method
3  process() {
4      this.open();
5      this.parse();
6      this.format();
7      this.save();
8  }
9 
10  // Abstract methods to be implemented by subclasses
11  abstract open();
12  abstract parse();
13  abstract format();
14  abstract save();
15}

Step 2: Implement Concrete Classes

Next, we create concrete classes for different document types, such as PDFProcessor and WordProcessor, that implement the abstract methods:

1class PDFProcessor extends DocumentProcessor {
2  open() {
3      console.log("Opening PDF file.");
4  }
5 
6  parse() {
7      console.log("Parsing PDF content.");
8  }
9 
10  format() {
11      console.log("Formatting PDF document.");
12  }
13 
14  save() {
15      console.log("Saving PDF file.");
16  }
17}
18 
19class WordProcessor extends DocumentProcessor {
20  open() {
21      console.log("Opening Word file.");
22  }
23 
24  parse() {
25      console.log("Parsing Word content.");
26  }
27 
28  format() {
29      console.log("Formatting Word document.");
30  }
31 
32  save() {
33      console.log("Saving Word file.");
34  }
35}

Step 3: Use the Template Method

Finally, we can use these concrete classes to process different types of documents:

1const pdfProcessor = new PDFProcessor();
2pdfProcessor.process();
3 
4console.log("
5");
6 
7const wordProcessor = new WordProcessor();
8wordProcessor.process();

When you run the above code, you will see the following output:

Opening PDF file.
Parsing PDF content.
Formatting PDF document.
Saving PDF file.

Opening Word file.
Parsing Word content.
Formatting Word document.
Saving Word file.

What's Next?

In this tutorial, we explored the Template Method pattern and how it can be used to define a consistent algorithm structure while allowing subclasses to implement specific details. In the next section, we will delve into another behavioral design pattern called the Visitor Pattern.