Template Method Pattern

Analogy categoryAnalogies

What Is the Template Method Pattern?

The Template Method pattern defines the skeleton of an algorithm in a base class method, deferring some of its individual steps to subclasses via abstract or overridable methods, so the overall sequence of steps stays fixed while specific steps vary. Unlike Strategy, which swaps a whole algorithm via composition, Template Method uses inheritance: the base class's template method calls a fixed sequence of step methods, and subclasses override only the steps that need to differ.

🏏

Cricket analogy: A cricket match's fixed sequence — toss, innings one, innings two, result — is the template method; the specific batting approach a team takes during 'innings one' is the overridable step that varies by team.

Structure: Abstract Class and Hook Methods

The base class declares a concrete templateMethod() (often marked final so subclasses can't override the overall sequence) that calls several step methods in order; some of those steps are abstract (subclasses must implement them), while others are hook methods with a default no-op or sensible default implementation that subclasses may optionally override to customize behavior without being forced to. This distinction between mandatory abstract steps and optional hooks gives Template Method fine-grained control over exactly how much subclasses are allowed to vary.

🏏

Cricket analogy: The ICC's fixed match-day protocol (final template method) mandates the toss and national anthems as required abstract steps every host broadcaster must show, but the pre-match entertainment segment is an optional hook each host country may customize or skip.

typescript

abstract class DataProcessor {
  // Template method: fixed sequence, marked final in spirit (not overridden)
  process(): void {
    const raw = this.readData();
    const cleaned = this.cleanData(raw);
    this.beforeSave(cleaned); // hook, optional
    this.saveData(cleaned);
  }

  protected abstract readData(): string[];
  protected abstract saveData(data: string[]): void;

  protected cleanData(data: string[]): string[] {
    return data.map(row => row.trim()).filter(row => row.length > 0);
  }

  protected beforeSave(_data: string[]): void {
    // default no-op hook; subclasses may override
  }
}

class CsvProcessor extends DataProcessor {
  protected readData(): string[] {
    return ['a,1', ' b,2 ', ''];
  }
  protected saveData(data: string[]): void {
    console.log('Saving CSV rows:', data);
  }
  protected beforeSave(data: string[]): void {
    console.log(`Validating ${data.length} rows before save`);
  }
}

new CsvProcessor().process();

Template Method vs Strategy

Because both patterns let subclasses/objects customize part of an algorithm, they're often confused, but the mechanism is fundamentally different: Template Method uses inheritance and is fixed at compile time — a subclass is baked in and can't be swapped at runtime — while Strategy uses composition and can be reassigned dynamically. A useful rule of thumb is that if you find yourself wanting to change an algorithm's variant behavior at runtime, or you're hitting the limits of single inheritance, that's a signal to refactor a Template Method hierarchy toward Strategy's composition-based approach instead.

🏏

Cricket analogy: A specific team's fixed 'always bat first if winning toss' policy baked into their long-standing team culture (Template Method) can't be swapped mid-series, whereas a captain's on-the-day choice of who opens the bowling (Strategy) can change every match.

Java's java.io.InputStream and its various read() overloads, and many test frameworks' setUp()/tearDown() lifecycle hooks around a fixed test-execution sequence, are widely used real-world Template Method implementations worth studying.

Hollywood Principle and Extensibility

Template Method is a textbook example of the Hollywood Principle — 'don't call us, we'll call you' — because subclasses never invoke the algorithm's overall flow directly; instead, the base class calls into the subclass's overridden step methods at exactly the points it decides. This inversion of control keeps the overall algorithm's invariants (ordering, error handling, resource cleanup) centralized and protected in the base class, so subclasses can extend behavior without being able to accidentally break the sequence or skip a mandatory step like closing a resource.

🏏

Cricket analogy: A franchise league's central scheduling office decides when each team plays (Hollywood Principle) rather than teams calling the office to request slots, so the tournament's overall structure stays protected even as team rosters change season to season.

Making the templateMethod() itself overridable defeats the pattern's purpose, since a subclass could then change the fixed sequence or skip mandatory steps like resource cleanup. In languages that support it, mark the template method final (or the equivalent) to enforce that only the individual steps, not the overall flow, can be customized.

Template Method fixes an algorithm's overall sequence in a base class while deferring individual steps to subclasses.
It uses inheritance, unlike Strategy's composition, so the algorithm variant is fixed at compile time per subclass.
Abstract steps must be implemented by every subclass; hook methods have a default and are optionally overridden.
The template method itself should typically be marked final so subclasses can't alter the overall flow.
The pattern embodies the Hollywood Principle: the base class calls into subclass steps, not the other way around.
Real-world examples include test-framework setUp()/tearDown() lifecycles and stream-processing base classes.
If you need to swap algorithm variants at runtime, that's a signal to move from Template Method toward Strategy.

Practice what you learned

1. What does the Template Method pattern fix in the base class, while letting subclasses vary specific parts?

2. What is the difference between an abstract step and a hook method in Template Method?

3. Why should the template method itself typically be marked final (or the language equivalent)?

4. Which design principle does Template Method exemplify, where the base class calls into subclass-provided steps rather than subclasses calling the base class's flow?

5. A reporting system always follows the same steps (fetch data, format data, export data) but the export format (PDF vs CSV) needs to be chosen and swapped at runtime based on user preference, not fixed at compile time per subclass. What does this suggest?

Was this page helpful?

State Pattern