14.模板方法模式

雨点打透心脏的1/2处 2023-10-05 21:13 26阅读 0赞

## 场景 ##

1.  由于水果店不断扩展结算方式，但是希望不影响购物流程。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70]

1.  但除了支付方式不同，其他购买步骤都是一样的。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 1]

1.  先将主流程框架逻辑（清点商品/计算价目/结算/送货上门）设计完成  
    ，再实现各模块小步骤。不能确实的步骤，作为虚拟方法，甩锅给子类实现。子类只需要聚焦自己的小步骤逻辑。

## 模板方法模式 ##

### 定义 ###

> 定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

### 结构 ###

*  抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。
    
     *  模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
     *  基本方法：是整个算法中的一个步骤，包含以下几种类型。
        
         *  抽象方法：在抽象类中申明，由具体子类实现。
         *  具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
         *  钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
 *  具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

### UML类图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 2]

### 代码实现 ###

#### 实现 ####

**抽象类**

/**
     * 模板方法模式
     * 购物车费用结算过程
     */
    public abstract class ShoppingCart {
        private List<Fruit> products = new ArrayList<>();
    
        public ShoppingCart(List<Fruit> products){
            this.products = products;
        }
    
    
        //提交订单主流程
        public void submitOrder(){
            //计算商品金额
            int money = balance();
            System.out.println("商品总金额为："+money+"元");
    
            //保存订单,支付方式就是模板
            pay(money);
    
            //送货上门
            sendHome();
    
        }
    
        //计算金额
        private int balance(){
            int money = 0;
            System.out.print("商品清单：");
            for (Fruit fruit : products){
                fruit.getFruit();
                System.out.print(",");
                money += fruit.price();
            }
            return money;
        }
    
        private void sendHome(){
            System.out.println("三公里以内，免费送货上门");
        }
    
        //付钱方式,模板方法
        protected abstract void pay(int money);
    }

**具体子类**

/**
     * 模板方法模式
     * 购物车费用结算过程
     */
    public class CartShopping extends ShoppingCart{
    
    
        public CartShopping(List<Fruit> products) {
            super(products);
        }
    
        @Override
        protected void pay(int money) {
            System.out.println("会员卡结算，立减10，金额："+ (money - 10)+",增加积分："+10*money);
        }
    }
    --------------------------------------------------------
    /**
     * 模板方法模式
     * 购物车费用结算过程
     */
    public class CashShopping extends ShoppingCart{
    
    
        public CashShopping(List<Fruit> products) {
            super(products);
        }
    
        @Override
        protected void pay(int money) {
            System.out.println("现金结算，假一罚十");
        }
    }

#### 客户端调用 ####

public class TestClient {
    
        public static void main(String[] args) {
            List<Fruit> products = new ArrayList<>();
            products.add(new Apple());
            products.add(new Banana());
            products.add(new Orange());
            System.out.println("-------------会员卡支付-------------");
            ShoppingCart shoppingCart = new CartShopping(products);
            shoppingCart.submitOrder();
            System.out.println("-------------现金支付-------------");
            ShoppingCart cashShopping = new CashShopping(products);
            cashShopping.submitOrder();
        }
    }

#### 结果 ####

-------------会员卡支付-------------
    商品清单：我是苹果,我是香蕉,我是桔子
    商品总金额为：300元
    会员卡结算，立减10
    金额：290,增加积分：3000
    三公里以内，免费送货上门
    -------------现金支付-------------
    商品清单：我是苹果,我是香蕉,我是桔子
    商品总金额为：300元
    现金结算，假一罚十
    三公里以内，免费送货上门

## 优缺点 ##

**优点**

*  它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
 *  它在父类中提取了公共的部分代码，便于代码复用。
 *  部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

**缺点**

*  对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
 *  父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。

## 模板方法模式的本质 ##

模板方法模式的本质：固定算法骨架

模板方法主要通过制定模板，把算法步骤固定下来，至于谁来实现，模板可以自己提供实现，也可以由子类去实现，还可以通过回调机制让其他类来实现。

## 使用场景 ##

*  算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
 *  当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
 *  当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210306151447218.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210306151456419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210306151507321.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ3NzUzMQ==,size_16,color_FFFFFF,t_70