Template Method Pattern

Description

Template Method is the behavioral pattern for "the same recipe, different details": a base class fixes the order of an algorithm's steps in one method and lets subclasses fill in the steps that vary. It's how frameworks hand you a skeleton - servlets, test fixtures, abstract collections - and call your code at the right moments. This skill covers the pattern, required steps versus optional hooks, and when composition is the better choice.

You export reports as CSV and as Markdown. Both exporters do the same steps - write a header, write each row, write a footer - but the code is duplicated:

class CsvExporter {
    String export(List<Row> rows) {
        StringBuilder out = new StringBuilder("name,score\n");
        for (Row r : rows) out.append(r.name()).append(',').append(r.score()).append('\n');
        return out.toString();
    }
}
class MarkdownExporter {
    String export(List<Row> rows) {
        StringBuilder out = new StringBuilder("| name | score |\n|---|---|\n");
        for (Row r : rows) out.append("| ").append(r.name()).append(" | ").append(r.score()).append(" |\n");
        return out.toString();
    }
}

class CsvExporter:
    def export(self, rows: list[Row]) -> str:
        out = ["name,score\n"]
        for r in rows:
            out.append(f"{r.name},{r.score}\n")
        return "".join(out)


class MarkdownExporter:
    def export(self, rows: list[Row]) -> str:
        out = ["| name | score |\n|---|---|\n"]
        for r in rows:
            out.append(f"| {r.name} | {r.score} |\n")
        return "".join(out)

When you add sorting, or skipping empty rows, you must remember to change every copy.

We'll go from simple to more technical:

1. The pattern: a final template method, abstract steps and hooks.
2. How it works, step by step - "don't call us, we'll call you".
3. Where you'll see it in the standard libraries and frameworks.
4. Inheritance costs, and Template Method versus Strategy.

The pattern

Template Method puts the fixed sequence of steps in one method of an abstract base class (the template method) and lets subclasses fill in the steps that vary.

abstract class ReportExporter {
    // The template method: the order of steps is fixed here, once.
    public final String export(List<Row> rows) {
        StringBuilder out = new StringBuilder();
        out.append(header());
        for (Row r : rows) {
            if (includeRow(r)) out.append(formatRow(r));
        }
        out.append(footer());
        return out.toString();
    }

    protected abstract String header();              // must be provided
    protected abstract String formatRow(Row r);      // must be provided
    protected String footer() { return ""; }         // hook: optional
    protected boolean includeRow(Row r) { return true; }   // hook: optional
}

class CsvExporter extends ReportExporter {
    protected String header() { return "name,score\n"; }
    protected String formatRow(Row r) { return r.name() + "," + r.score() + "\n"; }
}

from abc import ABC, abstractmethod
from typing import final


class ReportExporter(ABC):
    # The template method: the order of steps is fixed here, once.
    @final
    def export(self, rows: list[Row]) -> str:
        out = [self.header()]
        for r in rows:
            if self.include_row(r):
                out.append(self.format_row(r))
        out.append(self.footer())
        return "".join(out)

    @abstractmethod
    def header(self) -> str: ...                 # must be provided

    @abstractmethod
    def format_row(self, r: Row) -> str: ...     # must be provided

    def footer(self) -> str:                     # hook: optional
        return ""

    def include_row(self, r: Row) -> bool:       # hook: optional
        return True


class CsvExporter(ReportExporter):
    def header(self) -> str:
        return "name,score\n"

    def format_row(self, r: Row) -> str:
        return f"{r.name},{r.score}\n"

How it works, step by step

1. Write the algorithm once in the base class, in a method marked final so subclasses can't change the order. (In Python, @typing.final makes a type checker such as mypy reject an override; the interpreter itself doesn't stop one.)
2. Steps that differ become abstract methods: every subclass must implement them.
3. Optional steps become hooks: methods with a sensible default that subclasses may override.
4. Subclasses only fill in the blanks; they never call the template method's steps themselves.
5. "Don't call us, we'll call you" - the base class calls down into the subclass.

Where you'll see it

• java.util.AbstractList: implement get() and size(), and you get iteration, contains, indexOf and more for free.
• java.io.InputStream: subclasses implement one read(); the bulk read(byte[], ...) methods are built on top of it.
• HttpServlet.service() decides which of doGet() / doPost() to call.
• Python's collections.abc.Sequence: implement __getitem__ and __len__, and you get in, iteration, index and count for free; unittest.TestCase runs setUp, the test and tearDown in a fixed order.
• Test frameworks run setup, the test and teardown in a fixed order.

Choosing among the behavioral patterns

Common mistakes

Check yourself

Try to answer before opening each one - recalling beats re-reading.

1. Why is the template method declared final?

2. What's the difference between an abstract step and a hook?

3. When would you pick Strategy over Template Method for the part that varies?

Key takeaways

• The base class fixes the order of steps in one final template method.
• Required steps are abstract; optional steps are hooks with a default.
• Subclasses fill in blanks - the base class calls them, not the other way round.
• Great for removing duplicated workflows; watch out for fragile base classes.
• Composition with callbacks (like JdbcTemplate) is often the more flexible alternative.