Template Method pattern

Overview

The Template Method pattern defines the skeleton of an algorithm in a base class method and lets subclasses fill in specific steps. The template method itself is final: it calls steps in a fixed order, some implemented in the base class, some abstract, and some optional 'hooks' with default behavior.

It removes duplicated workflow code across similar classes, such as data importers that all open, parse, validate, save, and close, or games that all initialize, play turns, and announce a winner. Its main drawback is inheritance coupling; Strategy is the composition-based alternative.

When to use it

• Several classes share the same workflow but differ in some steps.
• You want to enforce step order.
• Framework extension points (lifecycle hooks).

Where it shows up in interviews

Where it is used in real software

Key terms

Template method

Final method defining the step order.

Primitive operation

Abstract step subclasses must implement.

Hook

Optional step with default behavior.

Hollywood principle

'Don't call us, we'll call you': the base calls subclass steps.

How it works, step by step

1. 1
   Write the algorithm once

   In the base class, as a final method.

2. 2
   Mark varying steps abstract

   parse(), transform().

3. 3
   Provide hooks for optional steps

   beforeSave() { }.

4. 4
   Implement subclasses

   Fill in the abstract steps only.

5. 5
   Keep the template final

   Subclasses cannot reorder steps.

Data importers

importFile(): read -> parse -> validate -> save -> report

Each importer is a few lines; the workflow and its order are defined once.

Implementation

1public abstract class DataImporter {2    // Template method: fixed order, cannot be overridden3    public final ImportReport importFile(Path path) throws IOException {4        String raw = Files.readString(path);5        List<Record> records = parse(raw);6        List<Record> valid = records.stream().filter(this::isValid).toList();7        afterValidate(valid);8        save(valid);9        return new ImportReport(records.size(), valid.size());10    }11 12    protected abstract List<Record> parse(String raw);        // required step13    protected void afterValidate(List<Record> records) {}     // hook14 15    private boolean isValid(Record r) { return r.id() != null && !r.id().isBlank(); }16    private void save(List<Record> records) { /* shared persistence */ }17}18 19public final class CsvImporter extends DataImporter {20    @Override21    protected List<Record> parse(String raw) {22        return raw.lines().skip(1).map(line -> line.split(","))23            .map(cols -> new Record(cols[0], cols[1])).toList();24    }25}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Template method not final.

  Fix: Subclasses might reorder or skip steps; make it final.

• Too many abstract steps.

  Fix: Provide defaults as hooks; keep required steps minimal.

Interview questions

Practice problems