The Template Method pattern defines the structure of an algorithm in an abstract class while allowing subclasses to provide implementation for certain steps. The abstract class contains a template method that defines the sequence of steps, both concrete operations and hook operations that may be overridden. Subclasses implement the hook operations as needed while preserving the overall structure and logic of the algorithm. This avoids duplicating code and allows subclasses flexibility within the defined framework.

1. Design Patterns
Template Method

2. Template Method
Template method defines the skeleton of an
algorithm in an operation, deferring some steps
to subclasses. Template Method lets
subclasses redefine certain steps of an
algorithm without changing the algorithm’s
structure

3. Abstract Class
Abstract methods that defines the basic steps
of the algorithm with
‘main’ method is public and defines the
algorithm structure (skeleton)
deferring actual implementation to subclasses

4. Components
Abstract methods (must override)
Non-abstract methods (can’t override)
Hook methods (may override - abstract)
Need a convention to separate Abstract from Hook methods (for example, DoMethod() may signify
that this is an abstract method that must be implemented)

5. Subclasses
Implements the abstract methods into real
actions
Subclasses implementation may differ.
Subclasses can override/redefine certain steps
of an algorithm but algorithm’s structure
remains intact

7. Strength
Changing behaviours - subclasses implements specific
behaviour
Avoids code duplication - overall work flow is implemented
once
Control - specifies what can and can’t change. Only
specific things are allowed to change

8. Code Sample
abstract class Generalization {
// 1. Standardize the skeleton of an algorithm in a "template" method
public void findSolution() {
stepOne();
stepTwo();
stepThr();
stepFor();
}
// 2. Common implementations of individual steps are defined in base class
protected void stepOne() { System.out.println( "Generalization.stepOne" ); }
// 3. Steps requiring peculiar impls are ";placeholders" in the base class
abstract protected void stepTwo();
abstract protected void stepThr();
protected void stepFor() { System.out.println( "Generalization.stepFor" ); }
}

9. Code Sample (contd)
abstract class Specialization extends Generalization {
// 4. Derived classes can override placeholder methods
// 1. Standardize the skeleton of an algorithm in a "template" method
protected void stepThr() {
step3_1();
step3_2();
step3_3();
}
// 2. Common implementations of individual steps are defined in base class
protected void step3_1() { System.out.println( "Specialization.step3_1" ); }
// 3. Steps requiring peculiar impls are "placeholders" in the base class
abstract protected void step3_2();
protected void step3_3() { System.out.println( "Specialization.step3_3" ); }
}

10. Code Sample (contd)
class Realization extends Specialization {
// 4. Derived classes can override placeholder methods
protected void stepTwo() { System.out.println( "Realization .stepTwo" ); }
protected void step3_2() { System.out.println( "Realization .step3_2" ); }
// 5. Derived classes can override implemented methods
// 6. Derived classes can override and "call back to" base class methods
protected void stepFor() {
System.out.println( "Realization .stepFor" );
super.stepFor();
} }
class TemplateMethodDemo {
public static void main( String[] args ) {
Generalization algorithm = new Realization();
algorithm.findSolution();
} }

11. Output (code_sample)
Generalization.stepOne
Realization.stepTwo
Specialization.step3_1
Realization.step3_2
Specialization.step3_3
Realization.stepFor
Generalization.stepFor

12. Real world Implementation
abstract class Game {
protected int playersCount;
abstract void initializeGame();
abstract void makePlay(int player);
abstract boolean endOfGame();
abstract void printWinner();
/* A template method : */
public final void playOneGame(int playersCount) {
this.playersCount = playersCount;
initializeGame();
int j = 0;
while (!endOfGame()) {
makePlay(j);
j = (j + 1) % playersCount;
}
printWinner();
}
}

13. Real world Implementation
//Now we can extend this class in order
//to implement actual games:
class Monopoly extends Game {
/* Implementation of necessary concrete methods */
void initializeGame() {
// Initialize players
// Initialize money
}
void makePlay(int player) {
// Process one turn of player
}
boolean endOfGame() {
// Return true if game is over
// according to Monopoly rules
}
void printWinner() {
// Display who won
}
/* Specific declarations for the Monopoly game. */
}

14. Real World Implementation
class Chess extends Game {
/* Implementation of necessary concrete methods */
void initializeGame() {
// Initialize players
// Put the pieces on the board
}
void makePlay(int player) {
// Process a turn for the player
}
boolean endOfGame() {
// Return true if in Checkmate or
// Stalemate has been reached
}
void printWinner() {
// Display the winning player
}
/* Specific declarations for the chess game. */
// ...
}

15. ..and the one-liner
The Template pattern does compile-time algorithm selection by subclassing.