The Template Method pattern encapsulates the invariant parts of an algorithm in a abstraction and allows concrete subclasses adjust the variant parts.

Components

• Abstract ****Template
  • Template Method: Define how to use Primitive Operations (invariant parts).
  • Abstract Primitive Operations (Override is needed): Abstract methods which are parts of the algorithm (variant parts).
  • Hook (Optional to override): Life cycle method within operations. The default behaviour of Hook is defended in Abstract ****Template.
• Concrete Subclasses
  • Implement Primitive Operations

V.S. Builder

• Builder pattern
  • A Builder defines setter methods and a build method to return the instance.
  • A Director can define how to use setter methods of a Builder object.
• Template Method pattern
  • A Template defines operations and a recipe method (Template Method) to proceed operations, which feels like the Director in Builder pattern.

SOLID Principle

✅ Single Responsibility Principle (SRP)

✅  Open/Closed Principle (OCP)

• Abstract ****Template is open for extension

✅  Liskov Substitution Principle (LSP) / Interface Segregation Principle (ISP)

• Subclasses must implement Primitive Operations.

✅  Dependency Inversion Principle (DIP)

• Subclasses extends from an Abstract ****Template.

OOP Langs Implementation

Inheritance

// Primitive Operations
interface Operation {
  startPlay(): void;
  endPlay(): void;
}

// Abstract Template
abstract class Game implements Operation {
	// Template method
	// @final
  public play(): void {
	  this.beforeStart(); // ← Hook method
    this.startPlay();
    this.endPlay();
  }
  
	// Primitive Operations
  protected abstract startPlay(): void;
  protected abstract endPlay(): void;
  
  // Hook (Optional to override)
  protected beforeStart(): void {
    // default: do nothing
  }

  // Reusable Shared Logic
  protected formatMessage(message: string): string {
    const timestamp = new Date().toISOString();
    return `[${timestamp}] ${message}`;
  }
}

// Concrete Subclasses
class Football extends Game {
  startPlay(): void {
    console.log("Football Game Started!");
  }
  endPlay(): void {
    console.log("Football Game Finished!");
  }
}

// Client
const game: Game = new Football();
game.play();

Interface Polymorphism (Less Common)

• To protect Template method to be closed to modify.
• To protect Hook methods’ default behaviour.

Polymorphism Decision

Go Implementation