• Behavioral design pattern
• Lets subclasses redefine algorithm steps without changing the algorithm's structure

Problem illustration: algorithm structure duplicated over multiple classes

How to define algorithm structure once for all subclasses, while letting them adapt some steps?

1. The AbstractClass defines concrete invariant steps and abstract variant steps

2. The AbstractClass defines a templateMethod that implements the algorithm structure by calling invariant and variant steps

3. The ConcreteClass implements the subclass-specific variant steps

• Break the target algorithm into steps
• Create an abstract base class that declares the template method and a set of (abstract) steps
• Implement the algorithm sketch in the template method
• Provide default step implementations (it's ok if all steps are abstract)
• Consider making the template method final
• For each variation of the algorithm, implement abstract steps in a subclass

// base class with template method
public abstract class BaseEmailNotifier {
  // template method
  public final void send(Message m) {
    check(m.getRecipient());
    check(m.getSubject());
    doSend(m);
  }
  
  // steps mandatory to override
  protected abstract void doSend(Message m);

  // common steps
  private void check(Recipient r) { /* ... */ }
  private void check(Subject s) { /* ... */ }
}

// concrete algorithm variants
public class GMailNotifier extends BaseEmailNotifier {
  protected void doSend(Message m) { /* ... */ }
}
public class ExchangeNotifier extends BaseEmailNotifier {
  protected void doSend(Message m) { /* ... */ }
}

Before: Algorithm duplicated in two subclasses