Template Pattern

Template Pattern

A template method defines the program skeleton of an algorithm.

One or more of the algorithm steps can be overridden by subclasses to allow differing behaviors while ensuring that the overarching algorithm is still followed.

In object-oriented programming, first a class is created that provides the basic steps of an algorithm design. These steps are implemented using abstract methods. Later on, subclasses change the abstract methods to implement real actions. Thus the general algorithm is saved in one place but the concrete steps may be changed by the subclasses.

The template method thus manages the larger picture of task semantics, and more refined implementation details of selection and sequence of methods. This larger picture calls abstract and non-abstract methods for the task at hand. The non-abstract methods are completely controlled by the template method but the abstract methods, implemented in subclasses, provide the pattern’s expressive power and degree of freedom. Some or all of the abstract methods can be specialized in a subclass, allowing the writer of the subclass to provide particular behavior with minimal modifications to the larger semantics. The template method (which is non-abstract) remains unchanged in this pattern, ensuring that the subordinate non-abstract methods and abstract methods are called in the originally intended sequence.

Structure diagram :

The template method is used to:

• let subclasses implement (through method overriding) behavior that can vary
• avoid duplication in the code: the general workflow structure is implemented once in the abstract class’s algorithm, and necessary variations are implemented in each of the subclasses.
• control at what point(s) subclassing is allowed. As opposed to a simple polymorphic override, where the base method would be entirely rewritten allowing radical change to the workflow, only the specific details of the workflow are allowed to change.
• The control structure (inversion of control) that is the result of the application of a template pattern is often referred to as the Hollywood Principle: “Don’t call us, we’ll call you.” Using this principle, the template method in a parent class controls the overall process by calling subclass methods as required.

Example:

Create abstract glass:

/**
* An abstract class that is common to several games in
* which players play against the others, but only one is
* playing at a given time.
*/
public 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();
	}
}

Now extend this class in order to implement actual games:

public 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
		return true;
	}

	void printWinner() {
		System.out.println("You won!!!");
	}
	/* Specific declarations for the Monopoly game. */
	// ...
}

public 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
		return true;
	}

	void printWinner() {
		// Display the winning player
	}
	/* Specific declarations for the chess game. */
	// ...
}

asf