【设计模式学习】02策略模式

---

  上一章学习了简单工厂模式，虽然不是23种设计模式之一，但也是帮助我打开了设计模式的大门，今天学习第二章，了解一下策略模式。

---

第2章 商场促销【策略模式】

首先明确商场收费系统的功能：

1. 需要输入某件商品的购买数量和单价，计算出该类商品的总价；
2. 商品的总价有多种计算方式：原价、打折促销、满减返利；
3. 购买信息应当在一个列表中显示出来（小票/凭据）；
4. 计算购买的所有种类商品的总价之和，得到本次购物的总价

先上效果图：

  界面的搭建就不多提了，写一个Form1.cs的脚本即可，下面着重介绍一下策略模式实现商场收费系统的代码。

  首先已知商场中商品总价的计算方式是不同的，可能是原价出售、打折促销、满减返利、第二件半价等等，但他们又都是对商品的总价进行处理的，所以可以创建一个关于现金管理的抽象类：

abstract class CashSuper
{
    //算法接口
    public abstract double acceptCash(double money);
}

  接着创建子类，这次我只计划了正常收费，打折促销和满减返利三种收费方式，计算方式非常简单不做赘述，以下是三个子类：

//原价出售
class CashNormal: CashSuper
{
    public override double acceptCash(double money)
    {
        return money;
    }
}
//打折促销
class CashRebate : CashSuper
{
    private double moneyRebate = 1d;
    public CashRebate(string moneyRebate)
    {
        this.moneyRebate = Convert.ToDouble(moneyRebate);
    }
    public override double acceptCash(double money)
    {
        return money * moneyRebate;
    }
}
//满减返利
class CashReturn : CashSuper
{
    private double moneyCondition = 0.0d;
    private double moneyReturn = 0.0d;
    public CashReturn(string moneyCondition,string moneyReturn)
    {
        this.moneyCondition = Convert.ToDouble(moneyCondition);
        this.moneyReturn = Convert.ToDouble(moneyReturn);
    }
    public override double acceptCash(double money)
    {
        return money - (int)(money / moneyCondition) * moneyReturn;
    }
}

  那么如何当计算的时候如何调用对应的类中的计算函数呢？这就涉及到了本次所学的策略模式。

• 策略模式（Strategy）的定义为：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响到使用算法的客户。

  创建一个上下文类CashContext，声明一个CashSuper父类对象，构造函数传入一个父类对象，并赋值给类内对象。如果想调用子类中的计算方法，调用GetResult()接口就可以了：
  上下文类：

class CashContext
{
    private CashSuper cs;
    public CashContext(CashSuper cs)
    {
        this.cs = csuper;
    }
    public double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
}

  调用方法：

CashContext cc= null;
switch (comboBox_Mode.SelectedItem.ToString())//下拉框的内容
{
	case "正常收费":
		cc = new CashContext(new CashNormal());
	case "打八折":
		cc = new CashContext(new CashRebate("0.8"));
	case "满300减100":
		cc = new CashContext(new CashReturn(“300”,“100”));
}
double money = Convert.ToDouble(textBox_Price.Text) * Convert.ToDouble(textBox_Num.Text);//商品总价=商品单价×数量
float result = cc.GetResult(money);

  刚实现的时候，我觉得这个策略模式跟简单工厂模式没什么区别啊？
  仔细对比了一下才发现相较于第一章所学的简单工厂模式是在客户端中直接声明一个父类对象，并通过工厂来产生一个子类实例，将该子类实例赋值给声明的父类对象。这么做的缺点是在客户端直接对算法类进行操作，而且工厂类只是解决了对象的创建问题，以后每次维护或者扩展收费方式都需要改动工厂类。

  策略模式则不会有这个问题，因为策略模式是将父类对象的实例和调用方法封装到一个上下文类(Context)中，在用户界面中只需要声明一个上下文类，实例化的时候并传入一个子类，即可通过上下文类中调用子类对象了。

• 简单点来说就是：简单工厂模式中，对象在客户端实例；策略模式中，上下文类在客户中实例，对象则封装在上下文类中，通过上下文类的接口调用。

---

  传统的策略模式在上面的案例中应用时，客户端代码中存在一个switch，如果要新添加一个算法类，那么还是要增加一个分支，还是有些复杂了，所以可以将策略模式和简单工厂模式结合起来。

  修改上下文类的代码，构造时传入的参数为一个字符串（下拉框当前选择的计算方式），并将switch转移到构造方法中来：

class CashContext
{
    private CashSuper cs;
    public CashContext(string cashType)
    {
        switch (cashType)
        {
            case "正常收费":
                cs = new CashNormal();
                break;
            case "打八折":
                cs = new CashRebate("0.8");
                break;
            case "打七折":
                cs = new CashRebate("0.7");
                break;
            case "打五折":
                cs = new CashRebate("0.5");
                break;
            case "满300减100":
                cs = new CashReturn("300", "100");
                break;
        }
    }
    public double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
}

  去掉了switch，客户端的代码就变得精简了很多：

CashContext cc = new CashContext(comboBox_Mode.SelectedItem.ToString());
double money = Convert.ToDouble(textBox_Price.Text) * Convert.ToDouble(textBox_Num.Text);//商品总价=商品单价×数量
float result = cc.GetResult(money);    

---

总结：

工厂模式、策略模式、两种模式的结合模式的特点：

• 工厂模式：在客户端中声明一个父类对象，通过工厂类的带参方法创建一个子类对象（根据参数判断创建哪种子类对象），并对客户端的父类对象赋值，通过客户端中的对象即可调用方法。
• 策略模式：在客户端中实例上下文类时就给类内声明的父类对象赋了值（传入的参数为实例的子类对象），想要调用对象的方法必须通过上下文类中的接口调用。
• 两种模式的结合模式：在客户端中实例上下文类，根据实例时传入的参数（可以是任意类型）确定实例哪种子类对象，想要调用对象的方法必须通过上下文类中的接口调用。

github项目源码在此：策略模式——商场促销