设计模式 - 模版方法

设计模式 - 模版方法

场景

小张的团队最近接受一个需求,实现实现一家咖啡店的冲泡咖啡和茶的冲泡自动化。之前这家咖啡店都是由咖啡师傅手动进行调制咖啡和茶。现在咖啡店需要引入自动化的点单和调制饮料的系统,小张负责实现调制饮料的功能。

咖啡师傅手工冲泡咖啡和茶的流程:

冲泡咖啡:

  1. 把水煮沸
  2. 用沸水冲泡咖啡
  3. 把咖啡倒入杯子
  4. 加糖和牛奶

冲泡茶:

  1. 把水煮沸
  2. 用沸水冲泡茶叶
  3. 把茶倒入杯子
  4. 加柠檬

小张先简单的想了一下, 如果直接实现程序,那么新建调制咖啡和调制茶的对象,在每个对象里面实现上述步骤。这样想了之后小张本想直接实现,但是由于信心不足,找老王帮他code review一下思路。 老王说,小张啊,你这实现也可以,不过不够优雅啊,你在仔细看一下上述步骤,有没有发现重复或者共性。

小张听了老王的话,觉得自己的设计应该太粗暴了,按照老王的引导,小张仔细看了上述步骤,发现上述步骤,1和4 是很相像的。4(加糖和牛奶/加柠檬)步骤相当于增加调料本质是相同的。那么他应该封装一下冲泡咖啡/茶的步骤算法。

找出共性进行封装,减少重复代码,使系统达到维护和扩展成本很低的状态。

老王夸奖到,很不错嘛,小张你已经慢慢的了解了面向对象(OOP)及使用设计模式的原因。你可以了解一下模版方法。

模版方法

模版方法实现冲泡咖啡

小张去了解了一下模版方法。针对上述冲泡步骤进行了思考。

应该有一个抽象的对象来描述冲泡饮料这一行为,并且抽象的类实现了具体冲泡对象的共性步骤也就是1.把水煮沸和3.把饮料倒入杯子。有两个具体的子类来具体实现冲泡茶和咖啡。
并且有些客户不需要加调料,那么需要对最后一步进行判断,是否添加调料。

我们来看一下小张的类图:

模版方法:在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中。模版方法使得子类可以在不改变算法结构的情况下,重新定义算法中某些步骤。

代码实现

冲泡饮料的抽象类
package xuelongjiang.designpartten.templatemethod;

/**
 *
 * 模板方法
 *
 *
 * @Author xuelongjiang
 */
abstract   public class CaffeineBeverage {

    //算法。 抽象类的算法是final 的不允许被子类修改
     public final  void   prepareRecipe(){

         //算法的具体步骤
         boilWater(); //烧水
         brew();//冲泡
         pourInCup();// 把饮料倒入杯子
         if(hook()){
             addCondiments();// 加调料
         }

    }


   public  abstract  void brew();

   public   abstract  void addCondiments();


    public void boilWater(){

        System.out.println("烧水");
    }


    public  void pourInCup(){
        System.out.println("把饮料倒入杯子");
    }

    /**
     *  钩子,具体实现可以对算法步骤做一些控制
     *
     * @return
     */
    public boolean hook(){
        return true;
    }

}

可以看到我们在冲泡咖啡/茶的抽象类中有一个hook方法,这个方法就是钩子方法。默认返回true,如果冲泡咖啡默认是加调料的那么子类就不用重写hook方法。

咖啡类
package xuelongjiang.designpartten.templatemethod;

/**
 * @Author xuelongjiang
 */
public class Coffee extends  CaffeineBeverage {


    @Override
    public void brew() {
        System.out.println("用沸水冲泡咖啡粉");
    }

    @Override
    public void addCondiments() {
        System.out.println("加糖和牛奶");
    }

    @Override
    public boolean hook() {
        return super.hook();
    }
}
茶类
package xuelongjiang.designpartten.templatemethod;

/**
 * @Author xuelongjiang
 */
public class Tea extends  CaffeineBeverage {


    @Override
    public void brew() {
        System.out.println("用沸水侵泡茶叶");
    }

    @Override
    public void addCondiments() {
        System.out.println("加柠檬");
    }


    @Override
    public boolean hook() {
        return super.hook();
    }
}
测试类
package xuelongjiang.designpartten.templatemethod;
/**
 * @Author xuelongjiang
 */
public class TemplateMethodTest {


    public static void main(String[] args) {
        CaffeineBeverage caffeineBeverage = new Tea();
        caffeineBeverage.prepareRecipe();

        System.out.println("-------------------");

        caffeineBeverage = new Coffee();
        caffeineBeverage.prepareRecipe();


    }
}

模版方法和策略模式的对比

  • 模版方法:控制算法内部。
  • 策略模式:不同算法的管理。

还记得我们在策略模式中武器示例吗? 拳头,木棍,手枪是实现接口的具体的算法,而不接口的算法内部。

两个模式很相像,但是解决的问题是不同。

要点

好莱坞原则:别调用(打电话给)我们,我们会调用(打电话给)你。(即高层组件对低层组件的方式是:别调用我们,我们会调用你们)。

  • 模版方法定义了算法的步骤,把这些步骤的实现延迟到了子类。
  • 模版方法模式为我们提供了一种代码复用的重要技巧。
  • 模版方法的抽象类可以定义具体方法、抽象方法和钩子。
  • 抽象方法由子类实现。
  • 为了防止子类改变模版方法中的算法,可以将模版方法声明为final
  • 模版方法和策略模式都封装了算法,一个用组合(策略模式),一个用继承(模版方法)。
<think>好的,用户想了解模板方法设计模式的原理与实现。首先,我需要回忆模板方法模式的基本概念。根据引用[3],模板方法模式定义了一个操作中的算法框架,将一些步骤推迟到子类中实现。这样可以在不改变算法结构的情况下,让子类重新定义某些步骤。 接下来,用户可能想知道原理部分。根据引用[4],模板方法模式通过抽象类中的模板方法规定算法结构和执行顺序,具体步骤由子类实现。这意味着父类控制流程,子类负责具体实现。需要解释这种分层的设计如何提高代码复用,并允许子类扩展特定步骤。 然后是结构部分。通常模板方法模式包含抽象类和具体子类。抽象类中的模板方法是final的,避免子类修改算法结构,而抽象方法由子类实现。比如引用[5]中的prepare_recipe()方法作为模板方法,定义了制作饮料的步骤,具体步骤如brew()和addCondiments()由子类实现。 实现方式方面,需要给出代码示例。比如制作咖啡和茶的例子,抽象类定义模板方法,子类实现具体步骤。根据引用[2],咖啡和茶的冲泡过程有相似的步骤,可以抽象到父类,不同步骤由子类覆盖。 应用场景部分,引用[3]提到当多个类有相同的方法但某些步骤不同时适用。例如数据处理流程、文档生成等。需要举几个例子说明适用情况。 可能还需要对比其他模式,比如策略模式。根据引用[1],策略模式使用组合来改变整个算法,而模板方法使用继承来改变部分步骤。这点需要区分清楚,避免用户混淆。 最后,总结优缺点。优点包括代码复用、扩展性,缺点则是子类必须遵循框架,可能不够灵活,如引用[1]提到可能限制子类灵活性。需要客观说明适用场景和潜在限制。 检查是否覆盖了用户需求:定义、原理、结构、实现、应用场景、优缺点。确保引用正确,每个引用对应的内容是否准确。比如引用[5]中的prepare_recipe作为模板方法的例子,引用[4]中的算法框架定义。确保回答结构清晰,分点明确,代码示例正确使用$$格式,行内公式用$符号。</think>### 模板方法设计模式的原理与实现 #### 一、定义与核心思想 模板方法模式(Template Method Pattern)是一种**行为型设计模式**,其核心思想是**定义一个算法的框架,允许子类在不改变算法结构的前提下重写某些步骤**。该模式通过抽象类实现,包含两类方法: 1. **模板方法**:定义算法骨架的固定流程,通常为`final`方法以防止子类修改[^3][^4]。 2. **抽象方法**:由子类实现的步骤,用于扩展或定制算法细节[^5]。 例如,制作咖啡和茶的流程可抽象为“烧水→冲泡→添加调料”的固定框架,而具体的冲泡和调料添加由子类实现[^2]。 --- #### 二、核心原理 1. **算法骨架固定化** 抽象类中通过模板方法规定执行顺序(如`prepare_recipe()`),子类仅需实现差异化的步骤(如`brew()`和`addCondiments()`)。 $$ \text{模板方法} = \text{固定步骤} + \text{抽象方法} $$ 2. **好莱坞原则(Hollywood Principle)** “不要调用我们,我们会调用你”——父类控制流程,子类被动响应具体步骤的调用。 --- #### 三、代码实现示例 以饮料制作为例,抽象类定义模板方法,子类实现具体步骤: ```java // 抽象类定义模板方法 abstract class CaffeineBeverage { // 模板方法(final防止子类修改结构) public final void prepareRecipe() { boilWater(); brew(); pourInCup(); addCondiments(); } // 公共步骤直接实现 void boilWater() { System.out.println("烧水"); } void pourInCup() { System.out.println("倒入杯子"); } // 子类必须实现的抽象方法 abstract void brew(); abstract void addCondiments(); } // 具体子类:咖啡 class Coffee extends CaffeineBeverage { void brew() { System.out.println("冲泡咖啡粉"); } void addCondiments() { System.out.println("加糖和牛奶"); } } // 具体子类:茶 class Tea extends CaffeineBeverage { void brew() { System.out.println("浸泡茶叶"); } void addCondiments() { System.out.println("加柠檬"); } } ``` --- #### 四、应用场景 1. **流程标准化**:多个类有相同流程但部分步骤不同(如数据处理、文档生成)[^3]。 2. **框架设计**:框架定义主流程,用户通过子类扩展细节(如Spring的`JdbcTemplate`)。 3. **避免代码重复**:将公共代码提升到父类,差异化代码下放至子类[^2]。 --- #### 五、优缺点分析 | **优点** | **缺点** | |----------------------------------|---------------------------------------| | 提高代码复用性(公共逻辑集中管理)[^2] | 可能因过度抽象增加系统复杂度 | | 子类只需关注差异部分 | 父类修改模板方法会影响所有子类[^1] | | 符合开闭原则(扩展开放,修改关闭) | 对简单流程可能造成设计过度[^3] | --- #### 六、与其他模式对比 - **策略模式(Strategy Pattern)** 策略模式通过组合替换整个算法,而模板方法模式通过继承修改部分步骤[^4]。 - **工厂方法模式(Factory Method)** 工厂方法是模板方法的一种特殊形式,专注于对象创建步骤的分工。 ---
评论 16
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值