The template method design pattern allows you to define the steps of an algorithm within a single method of a class. This allows you to constrain specific operations of an application to a single method.
Each step of the algorithm that the template method defines is an inner method. However, the template method only handles the implementation of some of its inner methods. Subclasses usually implement one or more of the template method’s inner methods.
A subclass can implement an abstract method, but it can’t redefine the algorithm implemented by a final method.
How the Template Method Works
A typical template method pattern will have the following structure:
final void templateMethod()
The first important thing to note is that templateMethod() is final, so no subclass can override this method. The other important thing to note is the three types of methods that the template method pattern uses: concrete, abstract, and hook.
The abstract class that houses the template method implements all its concrete methods, while concrete subclasses implement its abstract methods. The hook method usually does nothing by default, but a subclass does have the ability to override these methods when necessary.
Implementing the Template Method Pattern in Java
The template method pattern acts as a framework for an application. So, you’ll often see this pattern in software frameworks that provide the blueprint for application development.
For example, you can connect your application to one of many database systems. The steps to connect to and use a database follow a similar template:
public abstract class Database
final void databaseTemplate()
abstract void setDBDriver();
abstract void setCredentials();
abstract void createDB();
abstract void setData();
abstract void readData();
abstract void updateData();
abstract void deleteData();
System.out.println("Connecting to database...");
System.out.println("Destroying database connection...");
This example Database class uses the template method pattern to create a template that you can use with any database. To use a database, your application will need to connect to it, then destroy the connection after use. These activities are usually the same for all databases. Therefore, the abstract Database class can implement the connect() and closeConnection() methods.
The other methods in the template method will differ based on the type of database. For example, a MySQL database stores data in tables, while a MongoDB database stores data in collections. If you want to use a MySQL database in Java, simply create a new MySQL class that extends the Database class:
public class MySQL extends Database
System.out.println("Selecting MySQL driver...");
System.out.println("Setting MySQL database Credential...");
System.out.println("Creating a new table...");
System.out.println("Inserting data into database...");
System.out.println("Retrieving data from database...");
System.out.println("Updating data in database...");
System.out.println("Deleting data from database...");
The MySQL class implements all the abstract methods of the Database class. It can also override some concrete methods. However, it cannot touch the databaseTemplate() method, which uses the final keyword.
public class Main
public static void main(String args)
Database mySQLDB = new MySQL();
This Main class creates a new MySQL database object and uses the template method to simulate how an application would connect to the database. Running the main method prints the following output to the console:
In the output, you’ll notice that the application never calls the updateData() and deleteData() methods. This is why the hook methods are important. In an SQL database, you’ll want to create new tables, insert data, and view your data. However, you might not want to update or delete data. Therefore, the hook methods give subclasses the option to control these critical aspects of the algorithm.
By simply adding the code above to the MySQL class, the application now updates the data in the database. If you run the Main class again it will display the following updated output:
As you can see, the application is now updating the data in the Database.
The Benefits of Using the Template Method Design Pattern
A major benefit of the template method pattern is that it promotes software reusability. This design pattern also supports efficient programming. A subclass only needs to implement methods that are unique to its operation.
Additionally, an application that uses the template method pattern is more secure, as external classes cannot alter its operation structure.