All 15 Design Patterns in Java questions
More in Design Patterns in Java
How does the Builder pattern solve the "telescoping constructor" problem, and how would you implement it for a class with many optional parameters? What is the Strategy pattern, and how do Java 8's functional interfaces and lambdas make implementing it significantly more concise than the traditional interface-plus-implementation-classes approach? What is the Factory Method pattern, and how does it differ from the simpler Static Factory Method idiom (like List.of() or Optional.of())? What is the Adapter pattern, and when would you use it to make an existing class compatible with an interface it wasn't originally designed to implement? What is the difference between composition and inheritance as ways to reuse code, and why does the design principle "favor composition over inheritance" generally guide modern Java design (including many design patterns themselves)? How would you implement the Composite pattern to treat individual objects and groups of objects uniformly, such as a file system with files and directories? How would you implement the Observer pattern in Java, and how does it compare to using the built-in PropertyChangeSupport or a reactive streams library? How would you implement the Decorator pattern in Java, and how does java.io's InputStream/OutputStream class hierarchy exemplify this pattern in the JDK itself? How would you implement the Dependency Injection pattern manually (without a framework like Spring) using constructor injection, and what testability benefits does this provide? How would you implement the Visitor pattern in Java to add new operations to an existing class hierarchy without modifying those classes, and how do Java's sealed classes and pattern matching (switch expressions) provide a modern alternative?
Advertisement
Back to results for “Testing Strategy”
Java › Design Patterns in Java

What is the Template Method pattern, and how is it used to define the skeleton of an algorithm while letting subclasses customize specific steps?

Intermediate

Answer

Template Method defines the overall structure/sequence of an algorithm in a base class's (typically final) method, calling out to one or more abstract or overridable "hook" methods that subclasses implement to customize specific steps, without subclasses being able to alter the overall algorithm's sequence itself -- this is a common pattern in framework design, where the framework controls the overall flow (like a test runner's setup-execute-teardown sequence) while application code plugs in the specific behavior for individual steps.
public abstract class DataProcessor {
    public final void process() {  // template method -- final, defines fixed algorithm structure
        loadData();
        validate();
        transform();
        saveResults();
    }
    protected abstract void loadData();
    protected abstract void transform();
    protected void validate() { /* default implementation, can be overridden */ }
    protected void saveResults() { System.out.println("Saving..."); }
}

class CsvProcessor extends DataProcessor {
    protected void loadData() { /* CSV-specific loading */ }
    protected void transform() { /* CSV-specific transformation */ }
}
Real-world example A test framework's base test class defines a final runTest() template method calling setUp(), executeTest(), and tearDown() in a fixed sequence, with individual test classes only needing to override the specific steps relevant to them, guaranteeing every test consistently follows the same overall lifecycle regardless of what each individual test actually does.

Common follow-ups: How does Template Method differ from the Strategy pattern, given both involve customizable behavior?;Why is marking the template method itself as final considered important to preserving the pattern's intent?

OOP & Classes;Testing Strategy
All 15 Design Patterns in Java questions