工具篇-Java中的设计模式积累（二）-优快云博客

本文深入探讨了行为型设计模式中的模版模式和策略模式，分析了它们的定义、优缺点及应用场景，提供了详细的实现代码示例，帮助读者理解如何在实际项目中应用这些模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------------------------------------------行为型设计模式

1. 模版模式

为什么有模版模式：

定义一个算法的骨架，而将一些步骤的实现延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中某些步骤的具体实现；

优点：

模板方法模式通过把不变的行为搬到父类，去除了子类中的重复代码；
子类实现算法的某些细节，有助于算法的扩展；
父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”

缺点：

在模版模式中，子类执行的结果影响了父类的结果，会增加代码阅读的难度；

应用场景：

多个子类存在共有方法，且逻辑相同；　　　　
重要、复杂的算法，可以把核心算法设计为模板方法

实现：

模版模式中，基类方法的默认实现被退化为钩子Hooks的概念，他们被设计在子类中被重写，如果你期望一些方法在子类中不被重写，可以让他们为final。例如，

模版抽象类

 1 public abstract class HouseTemplate {
 2 
 3     protected HouseTemplate(String name){
 4         this.name = name;
 5     }
 6 
 7     protected String name;
 8 
 9     protected abstract void buildDoor();
10 
11     protected abstract void buildWindow();
12 
13     protected abstract void buildWall();
14 
15     protected abstract void buildBase();
16 
17     protected abstract void buildToilet();
18 
19     //钩子方法
20     protected boolean isBuildToilet(){
21         return true;
22     }
23 
24     //公共逻辑
25     public final void buildHouse(){
26 
27         buildBase();
28         buildWall();
29         buildDoor();
30         buildWindow();
31         if(isBuildToilet()){ 
32             buildToilet();
33         }
34     }
35 
36 }

子类1

 1 public class HouseOne extends HouseTemplate {
 2 
 3     HouseOne(String name){
 4         super(name);
 5     }
 6 
 7     HouseOne(String name, boolean isBuildToilet){
 8         this(name);
 9         this.isBuildToilet = isBuildToilet;
10     }
11 
12     public boolean isBuildToilet;
13 
14     @Override
15     protected void buildDoor() {
16         System.out.println(name +"的门要采用防盗门");
17     }
18 
19     @Override
20     protected void buildWindow() {
21         System.out.println(name + "的窗户要面向北方");
22     }
23 
24     @Override
25     protected void buildWall() {
26         System.out.println(name + "的墙使用大理石建造");
27     }
28 
29     @Override
30     protected void buildBase() {
31         System.out.println(name + "的地基使用钢铁地基");
32     }
33 
34     @Override
35     protected void buildToilet() {
36         System.out.println(name + "的厕所建在东南角");
37     }
38 
39     @Override
40     protected boolean isBuildToilet(){
41         return isBuildToilet;
42     }
43 
44 }

子类2

 1 public class HouseTwo extends HouseTemplate {
 2 
 3     HouseTwo(String name){
 4         super(name);
 5     }
 6 
 7     @Override
 8     protected void buildDoor() {
 9         System.out.println(name + "的门采用木门");
10     }
11 
12     @Override
13     protected void buildWindow() {
14         System.out.println(name + "的窗户要向南");
15     }
16 
17     @Override
18     protected void buildWall() {
19         System.out.println(name + "的墙使用玻璃制造");
20     }
21 
22     @Override
23     protected void buildBase() {
24         System.out.println(name + "的地基使用花岗岩");
25     }
26 
27     @Override
28     protected void buildToilet() {
29         System.out.println(name + "的厕所建在西北角");
30     }
31 
32 }

客户端

 1 public class Clienter {
 2 
 3     public static void main(String[] args){
 4         HouseTemplate houseOne = new HouseOne("房子1", false);
 5         HouseTemplate houseTwo = new HouseTwo("房子2");
 6         houseOne.buildHouse();
 7         houseTwo.buildHouse();
 8     }
 9 
10 }

可以看到，通过重写钩子方法自定义了房子1不需要建造厕所（fasle），另外可以参考这篇文章：设计模式学习笔记之九：模板方法模式。

2. 策略模式

为什么有策略模式：

Define a family of algorithms,encapsulate each one,and make them interchangeable.
定义一组算法（我觉得应该是一个行为的不同实现吧），将每个算法都封装起来，并且使它们之间可以互换。

通俗点讲是利用继承和多态机制，从而实现同一行为在不同场景下的不同实现吧。

优点：

算法可以自由切换；
避免使用多重条件判断；
扩展性良好，策略类遵顼里氏替换原则，增加一个策略只需要实现一个接口就可以了。

缺点：

策略模式造成很多的策略类，每个具体策略类都会产生一个新类；
所有的策略类都需要对外暴露，客户端必须知道所有的策略类，并自行决定使用哪一个策略类，违反了迪米特法，可使用工厂方法模式、代理模式修整这个缺陷。

应用场景：

如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，在运行时动态选择具体要执行的行为；
在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现；
对客户隐藏具体策略(算法)的实现细节，彼此完全独立。

实现：

策略模式有三种角色：

抽象策略角色这个是一个抽象的角色，通常使用接口或者抽象类去实现。比如Comparator接口；
具体策略角色包装了具体的算法和行为。就是实现了Comparator接口的实现一组实现类；
环境角色内部会持有一个抽象角色的引用，比如内部一定会有一个策略类的一个成员变量，这样在构建函数中就可以接收外部传递的具体的策略类。

例如，

    //抽象策略类 Strategy
    interface IStrategy {
        void algorithm();
    }

    //具体策略类 ConcreteStrategyA
    static class ConcreteStrategyA implements IStrategy {
        @Override
        public void algorithm() {
            System.out.println("Strategy A");
        }
    }

    //具体策略类 ConcreteStrategyB
    static class ConcreteStrategyB implements IStrategy {
        @Override
        public void algorithm() {
            System.out.println("Strategy B");
        }
    }

客户端，

 1     //上下文环境角色
 2     static class Context {
 3         private IStrategy mStrategy; // 引用
 4 
 5         public Context(IStrategy strategy) {
 6             this.mStrategy = strategy;
 7         }
 8 
 9         public void algorithm() {
10             this.mStrategy.algorithm();
11         }
12     }