What is Template Method Pattern?
The Template Method pattern is a behavioral design pattern that defines the program skeleton of an algorithm in a method, deferring some steps to subclasses. It lets you define a skeleton of an algorithm in a method, deferring some steps to subclasses. This pattern is particularly useful when you want to define a method structure in a superclass and let subclasses override certain steps of the algorithm without changing its structure.
In the Template Method pattern, the superclass defines the steps of the algorithm as a sequence of operations. It provides an abstract method that subclasses must implement, and it also has a template method that calls the abstract method and performs other steps. The template method ensures that the steps are executed in the correct order and that the subclass can override the abstract method without affecting the overall structure of the algorithm.
The Template Method pattern is often used in scenarios where you have a common algorithm that needs to be executed in a specific order, but some of the steps can be customized based on the requirements of the subclass. For example, the Template Method pattern can be used to implement a sorting algorithm, where the base class defines the steps for sorting, and subclasses can provide their own implementation for specific sorting algorithms like bubble sort, insertion sort, or quicksort.
Here’s a simple example to illustrate the Template Method pattern:
“`java
abstract class SortingAlgorithm {
// Define the template method
public final void sort(int[] array) {
validateInput(array);
performSort(array);
printResult(array);
}
// Abstract method to be implemented by subclasses
protected abstract void performSort(int[] array);
// Steps that are common to all sorting algorithms
private void validateInput(int[] array) {
if (array == null || array.length == 0) {
throw new IllegalArgumentException(“Input array cannot be null or empty”);
}
}
private void printResult(int[] array) {
for (int value : array) {
System.out.print(value + ” “);
}
System.out.println();
}
}
class BubbleSort extends SortingAlgorithm {
// Override the abstract method with bubble sort implementation
@Override
protected void performSort(int[] array) {
// Bubble sort algorithm
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
}
class InsertionSort extends SortingAlgorithm {
// Override the abstract method with insertion sort implementation
@Override
protected void performSort(int[] array) {
// Insertion sort algorithm
for (int i = 1; i < array.length; i++) {
int key = array[i];
int j = i - 1;
while (j >= 0 && array[j] > key) {
array[j + 1] = array[j];
j–;
}
array[j + 1] = key;
}
}
}
“`
In this example, the `SortingAlgorithm` class defines the template method `sort`, which calls the `validateInput` and `printResult` methods, and the abstract method `performSort`, which subclasses must implement. The `BubbleSort` and `InsertionSort` classes extend `SortingAlgorithm` and provide their own implementations for the `performSort` method, while reusing the common structure defined in the superclass.
The Template Method pattern is a powerful tool for defining the structure of an algorithm and allowing subclasses to customize certain steps without changing the overall structure. It promotes code reuse and makes the code more maintainable and flexible.
