Thilan Dissanayaka Software Architecture Apr 26

Template Pattern explained simply

Ever found yourself writing similar logic over and over, only to change a few steps each time?
That’s exactly what the Template Pattern helps you solve.

The Template Pattern is a behavioral design pattern that defines the skeleton of an algorithm in a method, deferring some steps to subclasses. It lets you reuse algorithm structure while letting subclasses refine certain steps without changing the overall logic.

What is the Template Pattern?

At its core, the Template Pattern:

  • Defines the outline (template) of an algorithm.
  • Implements the invariant parts (that don’t change).
  • Leaves the changing parts (abstract steps) to be defined by subclasses.

Think of it like a recipe: the steps are fixed, but the ingredients may vary.

Real-Life Analogy

Imagine you’re making a cup of tea or coffee. The process is almost the same:

  1. Boil water
  2. Brew drink
  3. Pour into cup
  4. Add condiments

The steps are identical, but "brew drink" and "add condiments" differ.

Template Pattern in Code (Java)

Let’s define an abstract class with a template method:

public abstract class Beverage {
    // Template method
    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    private void boilWater() {
        System.out.println("Boiling water");
    }

    private void pourInCup() {
        System.out.println("Pouring into cup");
    }

    // Abstract methods to be implemented by subclasses
    protected abstract void brew();
    protected abstract void addCondiments();
}

Now let’s create two subclasses: **Tea** and **Coffee**.

```java
public class Tea extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding lemon");
    }
}

```java
public class Coffee extends Beverage {
    @Override
    protected void brew() {
        System.out.println("Dripping coffee through filter");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding sugar and milk");
    }
}

And use them like this:

```java
public class MainProgram {
    public static void main(String[] args) {
        Beverage tea = new Tea();
        tea.prepareRecipe();

        System.out.println();

        Beverage coffee = new Coffee();
        coffee.prepareRecipe();
    }
}

**Output:**

Boiling water Steeping the tea Pouring into cup Adding lemon

Boiling water Dripping coffee through filter Pouring into cup Adding sugar and milk



## Key Components

- **Abstract Class (`Beverage`)**: Contains the template method and defines abstract steps.
- **Template Method (`prepareRecipe`)**: Defines the algorithm structure.
- **Concrete Classes (`Tea`, `Coffee`)**: Provide specific implementations for the abstract steps.

## When to Use the Template Pattern?

- When multiple classes share the same algorithm structure but differ in steps.
- When you want to avoid code duplication and increase reuse.
- When you want to control the algorithm’s structure tightly while allowing customization of parts.

---

## Advantages

✅ Promotes code reuse.  
✅ Ensures consistent algorithm structure.  
✅ Follows the Hollywood Principle: *“Don’t call us, we’ll call you.”* (i.e., the base class controls flow)

## Disadvantages

❌ Requires inheritance, which may reduce flexibility.  
❌ Can lead to class explosion if many subclasses are needed.  
❌ Harder to understand for beginners due to indirect control flow.

## Real-World Use Cases

- Frameworks that define **execution flows** (e.g., Spring’s `AbstractController` or `AbstractView`).
- Algorithms like **sorting**, **validation pipelines**, or **data import/export** workflows.
- UI frameworks that define base rendering logic but allow customization of widgets.

## Final Thoughts

The Template Pattern is perfect when you have an algorithm with a fixed structure, but with parts that vary. It helps you write **clean**, **reusable**, and **maintainable** code.

> Next time you find repeated logic that only changes in a few places — reach for the Template Pattern!

Happy templating! 🍵☕💻
ALSO READ
Template Pattern explained simply
Apr 26 Software Architecture

Ever found yourself writing similar logic over and over, only to change a few steps each time? That’s exactly what the **Template Pattern** helps you solve. The **Template Pattern** is a....

Factory Pattern explained simply
Apr 26 Software Architecture

# Factory Pattern Imagine you want to create objects — but you don't want to expose the creation logic to the client and instead ask a factory class to **create objects for you**. That's....

ACID Properties in Databases: The Key to Reliable Transactions
Apr 25 Database Systems

When working with databases, one thing is absolutely critical: keeping your data safe, consistent, and reliable. That's where ACID properties come in — a set of principles that ensure every....

REST API - Interview preparation guide
May 08 Interview Guides

## What is a REST API? A REST (Representational State Transfer) API is an architectural style for designing networked applications. It uses standard HTTP methods to interact with resources, making....

Kafka - Interview preparation guide
Jan 28 Interview Guides

## What is Apache Kafka? Apache Kafka is a distributed event streaming platform designed for high-throughput, fault-tolerant, and real-time data streaming. It is used for building real-time data....

Building a Web3 CLI Tool for the Ballerina Language: From Idea to Reality
Apr 26 WSO2

🚀 Excited to finally share my journey of building a web3 CLI tool for Ballerina! This tool bridges the gap between Ethereum smart contracts and the Ballerina programming language by automatically....