2. 程式人生 > >【設計模式】策略模式——以商場促銷為例

【設計模式】策略模式——以商場促銷為例

阿新 • • 發佈：2019-01-04

本文內容參考自《大話設計模式》（程傑 著）

注：以下程式碼為java實現

版本1

需求：

做一個商場收銀軟體，營業員根據客戶所購買商品的單價和數量，向客戶收費。

關鍵程式碼：

public class Cash
{
    private double  total   = 0;

    public void submit(int num, double price)
    {
        double totalPrices = num * price;
        total += totalPrices;

        System.out
 
.println("單價:" + price + " 數量:" + num + "合計:" + totalPrices);
    }

    public double getTotal()
    {
        return total;
    }

    public void setTotal(double total)
    {
        this.total = total;
    }
}

版本2

需求：

增加打折功能

思路1：修改程式碼，比如打7折，則total *= 0.7；
評價：如果取消打折，或者修改折扣，需要頻繁修改程式碼，不推薦。

思路2：增加折扣選項，關鍵程式碼如下：

public class Cash
{
    private double  total           = 0;
    private int     selectedIndex   = 0;

    public void selectFormLoad()
    {
        String[] selectForm = { "正常收費", "打8折", "打7折", "打5折" };
        selectedIndex = 0;
    }

    public void submit(int num, double price)
    {
        double
 
 totalPrices = 0;
        switch (selectedIndex)
        {
            case 0:
                totalPrices = num * price;
                break;
            case 1:
                totalPrices = num * price * 0.8;
                break;
            case 2:
                totalPrices = num * price * 0.7;
                break;
            case 3:
                totalPrices = num * price * 0.5;
                break;
        }
        total += totalPrices;
        System.out.println("單價:" + price + " 數量:" + num + "合計:" + totalPrices);
    }

    public double getTotal()
    {
        return total;
    }

    public void setTotal(double total)
    {
        this.total = total;
    }

    public int getSelectedIndex()
    {
        return selectedIndex;
    }

    public void setSelectedIndex(int selectedIndex)
    {
        this.selectedIndex = selectedIndex;
    }
}

問題：重複的程式碼太多，而且選項少，可變性不高！

版本3

需求：

可以靈活修改折扣，並且可以返利

//現金收費介面
public interface CashSuper
{
    public double acceptCash(double money);
}
//正常收費子類
public class CashNormal implements CashSuper
{

    public double acceptCash(double money)
    {
        return money;
    }
}
//打折收費子類
public class CashRebate implements CashSuper
{
    private double  moneyRebate = 1;

    public CashRebate(double moneyRebate)
    {
        this.moneyRebate = moneyRebate;
    }

    public double acceptCash(double money)
    {
        return money * moneyRebate;
    }
}
//返利收費子類
public class CashReturn implements CashSuper
{
    private double  moneyCondition  = 0;
    private double  moneyReturn     = 0;

    public CashReturn(double moneyCondition, double moneyReturn)
    {
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }

    public double acceptCash(double money)
    {
        double result = money;
        if (money >= moneyCondition)
        {
            result = money - money / moneyCondition * moneyReturn;
        }
        return result;
    }
}
//現金收費工廠類
public class CashFactory
{
    public static CashSuper createCash(String type)
    {
        CashSuper cs = null;
        if ("正常收費".equals(type))
        {
            cs = new CashNormal();
        }
        else if ("滿300返100".equals(type))
        {
            cs = new CashReturn(300, 100);
        }
        else if ("打8折".equals(type))
        {
            cs = new CashRebate(0.8);
        }

        return cs;
    }
}
//客戶端程式碼
public class Main
{
    private static double   total   = 0;

    public static void main(String[] args)
    {
        consume("正常收費", 1, 1000);
        consume("滿300返100", 1, 1000);
        consume("打8折", 1, 1000);

        System.out.println("總計:" + total);
    }

    public static void consume(String type, int num, double price)
    {
        CashSuper csuper = CashFactory.createCash(type);
        double totalPrices = 0;
        totalPrices = csuper.acceptCash(num * price);
        total += totalPrices;
        System.out.println("單價:" + price + " 數量:" + num + "合計:" + totalPrices);
    }
}

以上程式碼進行了抽象封裝，並使用了簡單的工廠類，靈活性高了很多。

問題：簡單工廠模式只是解決物件的建立問題，而且由於工廠本身包括了所有的收費方式，商場是可能經常性地更改打折額度和返利額度的，每次維護或擴充套件收費方式都要改動這個工廠，以致程式碼需要重新編譯部署，這是非常糟糕的處理方式，所以用它不是最好的辦法。面對演算法的時常變動，我們可以使用策略模式！

版本4

需求：

可以經常性地更改打折額度和返利額度，而且要維護成本較低。

策略模式（Strategy）：

它定義了演算法家族，分別封裝起來，讓它們之間可以互相替換，此模式讓演算法的變化，不會影響到使用演算法的客戶。

商場收銀時，如何促銷，用打折還是返利，其實都是一些演算法，最重要的是這些演算法是隨時都可能互相替換的，就這點變化，而封裝變化點是我們面向物件的一種很重要的思維方式。我們來看看策略模式的結構圖和基本程式碼：


這裡寫圖片描述 
//Strategy類，定義所有支援的演算法的公共介面
public interface Strategy
{
    public void algorithmInterface();
}
//ConcreteStrategy封裝了具體的演算法或行為，繼承於Strategy
public class ConcreteStrategyA implements Strategy
{
    public void algorithmInterface()
    {
        System.out.println("演算法A實現");
    }
}
public class ConcreteStrategyB implements Strategy
{
    public void algorithmInterface()
    {
        System.out.println("演算法A實現");
    }
}
public class ConcreteStrategyC implements Strategy
{
    public void algorithmInterface()
    {
        System.out.println("演算法C實現");
    }
}
//Context用一個ConcreteStrategy來配置，維護一個對Strategy物件的引用
public class Context
{
    private Strategy    strategy;

    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public void contextInterface()
    {
        strategy.algorithmInterface();
    }
}
//客戶端程式碼
public class Main
{
    public static void main(String[] args)
    {
        Context context;
        context = new Context(new ConcreteStrategyA());
        context.contextInterface();

        context = new Context(new ConcreteStrategyB());
        context.contextInterface();

        context = new Context(new ConcreteStrategyC());
        context.contextInterface();
    }
}

所以我們的可以進行以下修改：


這裡寫圖片描述 
//CashContext類
public class CashContext
{
    CashSuper   cashSuper;

    public CashContext(CashSuper cashSuper)
    {
        this.cashSuper = cashSuper;
    }

    public double acceptCash(double money)
    {
        return cashSuper.acceptCash(money);
    }
}
//客戶端程式碼
public class Main
{
    private static double   total   = 0;

    public static void main(String[] args)
    {
        consume("正常收費", 1, 1000);
        consume("滿300返100", 1, 1000);
        consume("打8折", 1, 1000);

        System.out.println("總計:" + total);
    }

    public static void consume(String type, int num, double price)
    {
        CashContext cashContext = null;

        if ("正常收費".equals(type))
        {
            cashContext = new CashContext(new CashNormal());
        }
        else if ("滿300返100".equals(type))
        {
            cashContext = new CashContext(new CashReturn(300, 100));
        }
        else if ("打8折".equals(type))
        {
            cashContext = new CashContext(new CashRebate(0.8));
        }

        double totalPrices = cashContext.acceptCash(num * price);
        total += totalPrices;

        System.out.println("單價:" + price + " 數量:" + num + "合計:" + totalPrices);
    }
}

問題：缺乏工廠模式的優勢，在客戶端要進行判斷。

版本5

將策略模式與簡單工廠模式結合起來：

//改造後的CashContext
public class CashContext
{
    CashSuper   cashSuper;

    public CashContext(CashSuper cashSuper)
    {
        this.cashSuper = cashSuper;
    }

    public CashContext(String type)
    {
        if ("正常收費".equals(type))
        {
            cashSuper = new CashNormal();
        }
        else if ("滿300返100".equals(type))
        {
            cashSuper = new CashReturn(300, 100);
        }
        else if ("打8折".equals(type))
        {
            cashSuper = new CashRebate(0.8);
        }
    }

    public double acceptCash(double money)
    {
        return cashSuper.acceptCash(money);
    }
}
//客戶端程式碼
public class Main
{
    private static double   total   = 0;

    public static void main(String[] args)
    {
        consume("正常收費", 1, 1000);
        consume("滿300返100", 1, 1000);
        consume("打8折", 1, 1000);

        System.out.println("總計:" + total);
    }

    public static void consume(String type, int num, double price)
    {
        CashContext cashContext = new CashContext(type);

        double totalPrices = cashContext.acceptCash(num * price);
        total += totalPrices;

        System.out.println("單價:" + price + " 數量:" + num + "合計:" + totalPrices);
    }
}

簡單工廠 和 策略模式+簡單工廠 的對比

客戶端程式碼：

//簡單工廠模式的用法
CashSuper csuper = CashFactory.createCash(type);
...
totalPrices = csuper.acceptCash(num * price);

//策略模式與簡單工廠模式結合的用法
CashContext cashContext = new CashContext(type);
double totalPrices = cashContext.acceptCash(num * price);

簡單工廠模式需要讓客戶端認識兩個類，CashSuper和CashFactory，而策略模式與簡單工廠模式結合的用法，客戶端就只需要認識一個類CashContext。耦合度更加降低。

我們在客戶端例項化的是CashContext的物件，呼叫的是CashContext的方法，這使得具體的收費演算法徹底地與客戶端分離。連演算法的父類CashSuper都不讓客戶端認識了。相當於建立了一個控制代碼類。

總結

策略模式是一種定義一系列演算法的方法，從概念上來看，所有這些演算法完成的都是相同的工作，只是實現不同，它可以以相同的方式呼叫所有的演算法，減少了各種演算法與使用演算法之間的耦合。

另外，它簡化了單元測試，因為每個演算法都有自己的類，可以通過自己的介面單獨測試。

遺留問題：如果我們需要增加一種演算法，比如滿200返50，你就必須要改CashContext中的if或switch程式碼，有沒有更低的維護成本？
（使用反射）

相關推薦

【設計模式】策略模式——以商場促銷為例

本文內容參考自《大話設計模式》（程傑 著） 注：以下程式碼為java實現 版本1 需求： 做一個商場收銀軟體，營業員根據客戶所購買商品的單價和數量，向客戶收費。 關鍵程式碼： public class Cash { pri

【設計模式】策略模式

concrete 方法 行為 無法 策略模式 避免 mint his 多態 1、定義 1.1標準定義 策略模式（StrategyPattern）是一種比較簡單的模式，也叫做政策模式（PolicyPattern）。其定義如下：Defineafamilyofalgorithms

【設計模式】——策略模式

【策略模式】 策略模式是一種定義一系列演算法的方法，從概念上看，所有這些演算法完成相同的工作，但是實現不同，它可以以相同的方式呼叫所有的演算法，減少各種演算法類與使用演算法類之間的耦合 【介紹】     • 作用：定義一系列演算法，把他們一個個封裝起來，並且使他們可以

【設計模式】——策略模式（Strategy）

行為型模式——策略模式（Strategy）定義： 它定義了演算法家族，分別封裝起來，讓它們之間可以相互替換，此模式讓演算法的變化，不會影響到使用演算法的客戶。 白話理解：最近雙11的活動大家都深有感觸，

【大話設計模式】——策略模式

一、開篇 　　上篇文章【大話設計模式】——簡單工廠模式告訴了我們一個網咖收費工廠物件如何建立收費形式（白天收費、夜間收費）的例項。簡單工廠程式碼中有很多 case分支語句 ,如果我們還想填加收費的形

【JS設計模式】策略模式的程式碼示例

策略模式的概念引用：        在軟體開發中也常常遇到類似的情況，實現某一個功能有多種演算法或者策略，我們可以根據環境或者條件的不同選擇不同的演算法或者策略來完成該功能。如查詢、排序等，一種常用的方法是硬編碼(Hard Coding)在一個類中，如需要提供多種查詢演算法，

【java設計模式】【行為模式Behavioral Pattern】策略模式Strategy Pattern

java sys algorithm stat 設計模式 log sets ace 行為模式 1 package com.tn.策略模式; 2 3 public class Client { 4 private Strategy strategy; 5

【javascript】javasrcipt設計模式之策略模式

影響 配置 可能 pan style 類庫 ava 自由 AC 策略模式支持在運行時由使用者選擇合適的算法，對於使用者而言不用關心背後的具體事項，而使用者自動根據當前程序執行的上下文和配置，從已有的算法列表中選擇出合適的算法來處理當前任務。 1.要解決的問題 2.如何實現

【設計模式-6】策略模式

策略模式 策略模式是對演算法的封裝，把一系列演算法封裝到對應的類中。並且這些類實現相同的介面，相互之間可以替換。 它把演算法的責任和演算法本身分割開，委派給不同的物件管理。 優點 策略模式的優點 策略模式提供了對“開閉原則”的完美支援，使用者可以在不修改原有系統的基礎

【設計模式】（一）-簡單工廠模式和策略模式

前言 最近開始和春哥，張鐸 ，銀平討論設計模式，成立了一個小菜變大鳥的小組，每天討論一個模式，並且把這個模式搞懂，每學一個新的模式，再回顧一下之前學的模式。這兩天學了簡單工廠模式和策略模式，發現兩個模式有很多相同之處，下面用商場促銷的例子來對兩個模式總結一下。 簡單工廠模式 1.

【設計模式學習筆記】策略模式

In computer programming, the strategy pattern (also known as the policy pattern) is a behavioral software design pattern that enables select

java設計模式之——策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式（行為型）【讀書筆記】

一、策略模式           定義：定義了演算法家族，分別封裝起來，讓他們之間可以互相替換，此模式讓演算法的變化，不會影響到演算法的客戶。           使用場景：策略模式是一種定義一系列演算法的方法，從概念上看，所有的這些演算法完成的都是相同的工作，只是實現不

【經典案例】Python詳解設計模式：策略模式

src 手動 pri 依賴 同學 ice als pass concrete 完成一項任務往往有多種方式，我們將其稱之為策略。 比如，超市做活動，如果你的購物積分滿1000，就可以按兌換現金抵用券10元，如果購買同一商品滿10件，就可以打9折，如果如果購買的金額超過500，

JavaScript設計模式之策略模式【組合委託】

>前言：語言只是工具，思想才是核心 >今天要總結的是 策略模式 策略在開發中的應用非常廣泛，所以也是非常常見且使用的設計模式。 在實際開發中，往往在實現一個功能時，有多種解決方案可行。 ### 常見場景： - 解壓：gzip演算法解壓，gzip演算法解壓 - 表單驗證：手機號驗證，郵箱驗證，密

【java設計模式】代理模式

pro 運行時間 cli .get aggregate stopped clas cnblogs dex 計算類中方法運行時間的幾種方案： Client: 1 package com.tn.proxy; 2 3 public class Client { 4

【Unity與23種設計模式】狀態模式（State）

unity public text 開始 sys 狀態模式 改變 val 繼承 定義： “讓一個對象的行為隨著內部狀態的改變而變化，而該對象也像是換了類一樣” 應用場景： 角色AI：控制角色在不同狀態下的AI行為 服務器連接狀態：開始連線、連線中、斷線等狀態 關卡進

【JAVA設計模式】外觀模式（Facade Pattern）

簡單 產生 creat ide oid dsm ref 功能 .net 一 定義 為子系統中的一組接口提供一個一致的界面。Facade模式定義了一個高層的接口，這個接口使得這一子系統更加easy使用。 二 案例 一個子系統中擁有3個模塊。每一個模塊

【設計模式】代理模式：靜態代理，動態代理，spring aop

spring 實現接口 找到 master 代碼 -s result java 統一 代理模式分為靜態代理和動態代理。我們拿鏈家來舉例子，我們本人是真實的對象，有真實的業務需求：需要去找房子；鏈家是中介，是代理類，他來幫我執行找房子的這個操作。 靜態代理： 　　1.實現一個

【Unity與23種設計模式】原型模式（Prototype）

模式 設計模式 unity 復制 ref 遊戲對象 代碼 設計 程序代碼 GoF中定義： “使用原型對象來產生指定類的對象，所以產生對象時，是使用復制原型對象來完成。” Unity中 開發者可以組裝遊戲對象 它可以包括復雜的組件 組裝好了之後，就可以將其存儲為Pre

【設計模式】module模式&&Revealing module （揭示）模式

但是 出版 參數傳遞 9.png 自然 指向 們的 private 初級 寫在前面 《head first設計模式》裏有一篇文章，是說使用模式的心智， 　　1、初學者"心智" ："我要為HELLO WORLD找個模式" 　　2、中級人員模式： "或許這裏我需要一個單件