Presentation on Template Method Design Pattern

Template Method
Design Pattern
Presented by- Ridwan Hossain Talukder [23]
Asif Mahmud [31]
Sanad Saha [17]
1

Outline
• Introduction to Template Pattern.
• Why is it needed?
• A real life scenario.
• How the pattern works.
• Why is it different from other similar design patterns?
2

What is template pattern?
• The Template Method Pattern defines the skeleton of
an algorithm in a method deferring some steps to subclasses.
• The Template Method Pattern lets subclasses redefine
certain steps of an algorithm.
• But it doesn’t allow the subclasses to change the algorithm’s
structure.
3

Generalized Class Diagram
4
AbstractClass
templateMethod()
primitiveOperation1()
ConcreteClass
1. The abstract class
contains the template
method
2. And abstract versions of
the operations used in
the template method
The template method
makes use of the
primitiveOperations to
implement an algorithm
There may be many
concreteClasses, each
implementing the full
set of operations
required by the
template method

ConcreteMethods& Hooked methods
• It might be a case that a primitiveOperation is similar
for all concreteClasses, then it can be declared as a final
method inside the abstractClass.
• Another case might be that a primitiveOperation is not
needed in some concreteClasses, then that method can
be written inside those concreteClasses with a empty
body which are called Hooked Methods
5

Real Life Scenario
• A Software which includes games in which players play
against the others, but only one is playing at a given
time.
6
CHESS
MONOPOLY

The Similarities & The Dissimilarities
Similarities
• All these games have more than one player
• Only a player can play/ make moves at a single time
• Every game has an end
Dissimilarities
• Each game has its own rules, regulations and method of play
• Each game has a different way to choose the winner
7

One Way to do it
public class Game {
public String game;
public Game(String game) {
this.game = game;
}
protected int playersCount;
void initializeGame() {
if(game.equals(“Chess”)) {
// Initialize players
// Put the pieces on the board
}
else if(game.equals(“Monopoly”)) {
// Initialize money
}
}
void makePlay(int player) { //Similar }
8

One Way to do it
boolean endOfGame(game) { //Similar }
void printWinner(game) { //Similar }
public void playOneGame(int playersCount) {
this.playersCount = playersCount;
initializeGame();
int j = 0;
while (!endOfGame()) {
makePlay(j);
j = (j + 1) % playersCount;
}
printWinner();
}
}
9

What is the problem?
• Every time a new game needs to be added, code have to
be modified.
• It violates a basic OOP rule which is -
Open for extension, closed for modification
10

Solution
11
Template
Method Design
Pattern!!!

Class Diagram
12
game
<<Template method>>
playOneGame()
<<Abstract Methods>>
initializeGame()
makePlay()
endOfGame()
<<Concrete Methods>>
printWinner()
chess
initializeGame()
makePlay()
endOfGame()
initializeGame()
makePlay()
endOfGame()
printWinner()
Monopoly
initializeGame()
makePlay()
endOfGame()

Implementation
abstract class Game {
protected int playersCount;
abstract void initializeGame();
abstract void makePlay(int player);
abstract boolean endOfGame();
/* 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();
}
/* Concrete Methods: */
void printWinner() {
// Displays who won
}
}
13

Implementation
class Monopoly extends Game {
/* Concrete implementation of abstract methods For MONOPOLY GAME */
// Initialize money
}
void makePlay(int player) {
// Process one turn of player
}
boolean endOfGame() {
// Return true if game is over
// according to Monopoly rules
}
/* Specific declarations for the Monopoly game. */
// ...
}
14

Implementation
class Chess extends Game {
/* Concrete implementation of abstract methods For CHESS GAME */
// 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
}
/* Specific declarations for the chess game. */
// ...
}
15

Applicability
• To implement the invariant parts of an algorithm once and leave it
up to subclasses to implement the behavior that can vary.
• When refactoring is performed and common behavior is identified
among classes. A abstract base class containing all the common
code (in the template method) should be created to avoid code
duplication and redundancy.
16

Another Powerful tool: The Hook
• Hook is a method that is declared in the abstract class
• “Hook” lets us to reconfigure our Template
• Hook gives us the choice if we want to override a method or not.
17

Using Hook in Template Pattern
18
abstract class AbstractClass {
final void templateMethod() {
primitiveOperation1();
concreteOperation();
if(HOOK_CustomerWantsOperation3()) {
}
}
abstract void primitiveOperation1();
final void concreteOperation() { }
boolean HOOK_CustomerWantsOperation3() {
if(condition satisfied) return true;
return false;
}
}

Difference with Strategy Pattern
• Strategy pattern means choosing an algorithm whereas Template
pattern means using an algorithm as a template to do similar but
not the same jobs.
• The Strategy pattern allows an algorithm to be chosen at runtime
by containment whereas with the Template method pattern this
happens at compile-time by subclassing the template.
• The difference consists in the fact that Strategy uses delegation
while the Template Methods uses the inheritance.
19

Presentation on Template Method Design Pattern

Recommended

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Presentation on Template Method Design Pattern (20)

Recently uploaded (20)

Presentation on Template Method Design Pattern