How do you define a common algorithm with variations using the template method pattern?

1 Why use the template method pattern?

The template method pattern can help you avoid code duplication and improve code cohesion. Imagine you have several classes that implement a similar algorithm, but with some differences in the details. For example, you may have different types of coffee makers that brew coffee in different ways, but share some common steps such as boiling water, adding coffee, and pouring into a cup. Instead of repeating the same code in each class, you can extract the common steps into a base class and define them as final methods. Then, you can declare some abstract methods that represent the variable steps and let the subclasses implement them according to their own logic. This way, you can define the algorithm once in the base class and call it as a template method, while letting the subclasses fill in the blanks.

2 How to implement the template method pattern?

To implement the template method pattern, you need to define an abstract base class that contains the template method and the common steps of the algorithm. The template method should be final and call the common and abstract methods in a fixed order. Additionally, some abstract methods should be defined in the base class that represent the variable steps of the algorithm, which should be protected and have meaningful names. Furthermore, concrete subclasses should be created that inherit from the base class and override the abstract methods with their own logic. Lastly, the template method in the base class can be used to execute the algorithm in different contexts, without overriding it or any of the common methods.

3 What are the benefits of the template method pattern?

The template method pattern has several advantages, such as promoting code reuse and reducing duplication by extracting the common logic into a base class. It also improves code cohesion and enables code extensibility, which follows the open-closed principle. Additionally, this pattern enhances code readability by using clear and consistent names for the methods. Ultimately, this pattern can help create a more organized and efficient algorithm.

4 What are the drawbacks of the template method pattern?

The template method pattern can come with some drawbacks, such as introducing unnecessary complexity and overhead if the algorithm is simple, creating tight coupling between the base class and subclasses, violating the Liskov substitution principle if preconditions or postconditions for the abstract methods differ, and limiting the flexibility of subclasses by imposing a rigid structure for the algorithm.

5 How to use the template method pattern in Java?

Here is an example of how to use the template method pattern in Java to implement different types of coffee makers:

// The abstract base class that defines the template method and the common steps
public abstract class CoffeeMaker {
  // The template method that calls the common and abstract methods in a fixed order
  public final void makeCoffee() {
    boilWater();
    brewCoffee();
    addCondiments();
    pourIntoCup();
  }
  // The common method that boils water
  private final void boilWater() {
    System.out.println("Boiling water");
  }
  // The common method that pours coffee into a cup
  private final void pourIntoCup() {
    System.out.println("Pouring coffee into a cup");
  }
  // The abstract method that brews coffee
  protected abstract void brewCoffee();
  // The abstract method that adds condiments
  protected abstract void addCondiments();
}
// The concrete subclass that implements the French press coffee maker
public class FrenchPressCoffeeMaker extends CoffeeMaker {
  // The overridden method that brews coffee using a French press
  @Override
  protected void brewCoffee() {
    System.out.println("Brewing coffee using a French press");
  }
  // The overridden method that adds no condiments
  @Override
  protected void addCondiments() {
    System.out.println("No condiments added");
  }
}
// The concrete subclass that implements the drip coffee maker
public class DripCoffeeMaker extends CoffeeMaker {
  // The overridden method that brews coffee using a drip filter
  @Override
  protected void brewCoffee() {
    System.out.println("Brewing coffee using a drip filter");
  }
  // The overridden method that adds sugar and milk
  @Override
  protected void addCondiments() {
    System.out.println("Adding sugar and milk");
  }
}
// The main class that uses the template method to make different types of coffee
public class Main {
  public static void main(String[] args) {
    // Create a French press coffee maker and make coffee
    CoffeeMaker frenchPress = new FrenchPressCoffeeMaker();
    frenchPress.makeCoffee();
    // Output:
    // Boiling water
    // Brewing coffee using a French press
    // No condiments added
    // Pouring coffee into a cup
    // Create a drip coffee maker and make coffee
    CoffeeMaker drip = new DripCoffeeMaker();
    drip.makeCoffee();
    // Output:
    // Boiling water
    // Brewing coffee using a drip filter
    // Adding sugar and milk
    // Pouring coffee into a cup
  }
}        

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?