The Template Method design pattern defines the template of an algorithm as its individual steps. The descendants then implement these steps and represent replaceable algorithms.
Several algorithms with the same structure, but with different behavior, may
appear in our application. Saving a document using a specific file format is
often used as an example. File writers for specific file types have different
behavior, but all the documents have the same structure (header, body, and
footer). Therefore, all the writing algorithms consist of the same primitive
WriteFooter()). The Template Method design pattern utilizes this to
create a unified interface for them.
The Template Method pattern implements the skeleton of an algorithm using methods representing its individual steps. These are called primitive operations and are abstract, private methods. The pattern is represented by an abstract class whose descendants then implement specific algorithms.
The algorithms (concrete classes) then have a unified interface (such as
WriteFooter()), but perform these steps by themselves. This
interface is private, and its called step by step by a public method implemented
in the abstract class (here, it's named
practice, it could be named as e.g.
Save(). The descendants will
inherit the method and implement the primitive operations. The problem will be
broken down into subproblems and simplified.
Although these are different algorithms, we get a unified interface that will make the code readable and the further expanding of the system easier.
The number of steps should be as small as possible, and they are
often distinguished by a prefix (e.g.
The Template Method pattern is basically a subpattern of the Strategy pattern.