Master Template, Strategy, and Factory Patterns with Real‑World Java Examples

Design patterns are essential for both interviews and daily development, but learning them without concrete scenarios makes them easy to forget. This guide uses concrete examples to ensure you master three common patterns.

1. A Silly Penguin Story

A journalist asks many penguins what they do every day; most answer "eat, sleep, beat beans," while the last one says "I am the bean." The joke sets the stage for the three patterns.

2. Template & Strategy Patterns

2.1 Implementation Approaches

We start with the simplest, most “low‑level” implementation, then move to a conventional approach, followed by Template Method and Strategy patterns.

2.1.1 Low‑Level Approach

<code>public class LittlePenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("用小翅膀打豆豆");
    }
}

public class MiddlePenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("用圆圆的肚子打豆豆");
    }
}

public class BigPenguin {
    public void everyDay() {
        System.out.println("吃饭");
        System.out.println("睡觉");
        System.out.println("拿鸡毛掸子打豆豆");
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("littlePenguin:");
        new LittlePenguin().everyDay();
        System.out.println("middlePenguin:");
        new MiddlePenguin().everyDay();
        System.out.println("bigPenguin:");
        new BigPenguin().everyDay();
    }
}</code>

This straightforward style is easy to write but quickly becomes duplicated in large projects.

2.1.2 Conventional Approach

<code>public class LittlePenguin {
    public void eating() { System.out.println("吃饭"); }
    public void sleeping() { System.out.println("睡觉"); }
    public void beating() { System.out.println("用小翅膀打豆豆"); }
}

public class MiddlePenguin {
    public void eating() { System.out.println("吃饭"); }
    public void sleeping() { System.out.println("睡觉"); }
    public void beating() { System.out.println("用圆圆的肚子打豆豆"); }
}

// BigPenguin omitted for brevity

public class Test {
    public static void main(String[] args) {
        LittlePenguin p1 = new LittlePenguin();
        p1.eating(); p1.sleeping(); p1.beating();
        // similar calls for other penguins
    }
}</code>

Here each behavior is encapsulated in its own method, making the code clearer but still repetitive.

2.1.3 Template Method Pattern

Definition: An abstract class defines the skeleton of an algorithm, while subclasses override specific steps. It is a behavioral pattern.

<code>public abstract class Penguin {
    public void eating() { System.out.println("吃饭"); }
    public void sleeping() { System.out.println("睡觉"); }
    public abstract void beating();
    public void everyDay() {
        eating();
        sleeping();
        beating();
    }
}

public class LittlePenguin extends Penguin {
    @Override public void beating() { System.out.println("用小翅膀打豆豆"); }
}

public class MiddlePenguin extends Penguin {
    @Override public void beating() { System.out.println("用圆圆的肚子打豆豆"); }
}

public class BigPenguin extends Penguin {
    @Override public void beating() { System.out.println("拿鸡毛掸子打豆豆"); }
}

public class Test {
    public static void main(String[] args) {
        new LittlePenguin().everyDay();
        new MiddlePenguin().everyDay();
        new BigPenguin().everyDay();
    }
}</code>

2.1.4 Strategy Pattern

Definition: A class’s behavior or algorithm can be changed at runtime by composing it with different strategy objects.

<code>public abstract class Penguin {
    public void eating() { System.out.println("吃饭"); }
    public void sleeping() { System.out.println("睡觉"); }
    public abstract void beating();
}

public class LittlePenguin extends Penguin {
    @Override public void beating() { System.out.println("用小翅膀打豆豆"); }
}
// MiddlePenguin and BigPenguin similar

public class BehaviorContext {
    private Penguin penguin;
    public BehaviorContext(Penguin p) { this.penguin = p; }
    public void setPenguin(Penguin p) { this.penguin = p; }
    public void everyDay() {
        penguin.eating();
        penguin.sleeping();
        penguin.beating();
    }
}

public class Test {
    public static void main(String[] args) {
        BehaviorContext ctx = new BehaviorContext(new LittlePenguin());
        ctx.everyDay();
        ctx.setPenguin(new MiddlePenguin());
        ctx.everyDay();
        ctx.setPenguin(new BigPenguin());
        ctx.everyDay();
    }
}</code>

2.2 Template vs Strategy

Both patterns satisfy the Open‑Closed Principle, but they differ in coupling, abstraction, and when the algorithm is bound (compile‑time vs runtime). The article lists similarities and differences in detail.

3. Factory Pattern

The factory pattern creates objects without exposing the creation logic to the client, using a common interface.

<code>public abstract class Penguin {
    public void eating() { System.out.println("吃饭"); }
    public void sleeping() { System.out.println("睡觉"); }
    public abstract void beating();
    public void everyDay() { eating(); sleeping(); beating(); }
}

public class PenguinFactory {
    private static final Map<String, Penguin> map = new HashMap<>();
    static {
        map.put("littlePenguin", new LittlePenguin());
        map.put("middlePenguin", new MiddlePenguin());
        map.put("bigPenguin", new BigPenguin());
    }
    public static Penguin getPenguin(String name) { return map.get(name); }
}

public class Test {
    public static void main(String[] args) {
        Penguin p = PenguinFactory.getPenguin("littlePenguin");
        p.everyDay();
        p = PenguinFactory.getPenguin("middlePenguin");
        p.everyDay();
        p = PenguinFactory.getPenguin("bigPenguin");
        p.everyDay();
    }
}</code>

Combining factory with template (or strategy) removes large switch/if‑else blocks, as shown in a real‑world payment‑system example.

4. Conclusion

After reading, the three patterns—Template Method, Strategy, and Factory—should be firmly embedded in your mind. Review your own projects, identify where these patterns appear, and deepen your understanding through practical application.