This lesson follows Strategy. Strategy varies behavior through composition. Template Method varies steps through inheritance.

Template Method defines an algorithm's skeleton in a base-class method. Subclasses provide or override selected steps. The cost is coupling each subclass to that sequence and its extension rules.

Find the repeated sequence

A tool imports labels from plain lines or a JSON array. Decoding differs. Trimming values and rejecting empty labels are shared. Copying all three steps into each importer creates two places to maintain the same validation rule.

abstract class LabelImporter {
  run(source: string): string[] {
    const labels = this.decode(source).map(label => label.trim());
    if (labels.some(label => label.length === 0)) {
      throw new Error("Empty label");
    }
    this.afterLoad(labels.length);
    return labels;
  }
  protected abstract decode(source: string): string[];
  protected afterLoad(_count: number): void {}
}
class LineImporter extends LabelImporter {
  protected decode(source: string) { return source.split("\n"); }
}
class JsonImporter extends LabelImporter {
  protected decode(source: string): string[] {
    const value: unknown = JSON.parse(source);
    if (!Array.isArray(value) || !value.every(item => typeof item === "string")) {
      throw new Error("Expected an array of strings");
    }
    return value;
  }
  protected afterLoad(count: number) {
    console.log("Imported", count, "labels");
  }
}

new LineImporter().run(" alpha\nbeta "); // ["alpha", "beta"]
new JsonImporter().run('[" alpha", "beta "]'); // same labels

Distinguish required steps, defaults, and hooks

Extension point	Meaning	Here
Abstract step	every concrete subclass must provide it	decode
Default step	base behavior exists and may be replaced	a separately extracted normalize step could use a default
Hook	optional extension with an empty default	afterLoad

Preserve the skeleton's guarantees

Do not add an override point for every line. Every extension point increases the behaviors the base class must support. A subclass that disables required validation violates the base promise even if its methods compile.

Map the roles

Role	In this example	Job
Abstract class	LabelImporter	Declares the methods that act as algorithm steps, plus run(), the template method that calls them in a fixed order. Steps can be abstract or have a default implementation.
Concrete classes	LineImporter, JsonImporter	Override the steps they need to. They must not override the template method itself.

Reach for it when subclasses should vary steps, not the whole algorithm

• you want clients to extend only particular steps of an algorithm, not the whole algorithm or its structure. The template method turns a monolithic algorithm into a series of steps that subclasses can extend while the superclass keeps the structure intact.
• several classes contain almost identical algorithms with small differences. Without the pattern, a change to the algorithm means editing every class. Turning it into a template method lets you pull the similar steps up into a superclass and leave only the differing code in subclasses.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Analyze the target algorithm to see whether you can break it into steps. Decide which steps are common to all subclasses and which are always unique.
2. Create the abstract base class. Declare the template method and a set of abstract methods for the steps. In the template method, call the steps in order to outline the algorithm's structure. Consider marking the template method final so subclasses cannot override it.
3. All steps can be abstract, but some benefit from a default implementation, so subclasses do not have to implement them.
4. Think about adding hooks between the crucial steps of the algorithm.
5. For each variation of the algorithm, create a concrete subclass. It must implement every abstract step and may override some of the optional ones.

Name what it costs

You gain	You pay
Clients override only certain parts of a large algorithm, so changes elsewhere affect them less	Some clients may be limited by the skeleton the algorithm provides
Duplicate code moves into a superclass	A subclass that suppresses a default step through an override can violate the Liskov substitution principle
Optional hooks give extension points around important steps	The more steps a template has, the harder it is to maintain

Do not confuse it with its neighbors

Pattern	How it relates
Factory Method	Factory Method is a specialization of Template Method. A factory method can also serve as one step in a larger template method.
Strategy	Template Method is based on inheritance: you change parts of an algorithm by extending those parts in subclasses. It works at the class level, so it is static. Strategy is based on composition: you change parts of an object's behavior by supplying different strategies. It works at the object level, so you can switch behavior at runtime.

Retrieve and apply

Mark shared steps, required steps, and hooks in one repeated workflow. Continue to Visitor when new operations must cover several stable element types.