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! 🍵☕💻