设计模式之我见（二）——策略模式

假如现在你的公司接到了一个项目，要做商场里的促销系统。

老实说，这难不倒学过简单工厂模式的你。

嗯，话虽如此，我们还是先来使用简单工厂简单实现一下，毕竟就怕眼高手低，用的不熟练。

//现金收费抽象类
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 class CashRebate(string moneyRebate)
    {
        this.moneyRebate = double.Parse(moneyRebate);
    }
    
    public override double acceptCash(double money)
    {
        return money*moneyRebate ;
    }
}


//现金工厂类
class CashFactory
{
    public static CashSuper createCashAccept(string type)
    {
        CashSuper cs =null;
        switch(type)
        {
            case "正常收费":
                cs = new CashNormal();
                break;
            case "打八折":
                cs = new CashRebate("0.8");
                break;
        }    
        return cs;
    }
}

工厂建好了，剩下的就是根据商场选择的营销模式，在客户端中调用工厂即可得出打折结果。

但不知聪明的你有没有注意到不好的地方，我们如果要新增打折模式，那么就要新增一个类，同时又要去修改工厂里的switch代码，这不算一种很好的处理方式。

所以，接下来有请我们的策略模式闪耀登场。

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

听不懂？没关系，看完代码你就懂了。

 

先前写的抽象父类和具体打折子类我们都不需要修改，只是我们要用一个Context（上下文）类来取代工厂类:

class CashContext
{
    private CashSuper cs;
    public CashContext(CashSuper cs)
    {
        this.cs = cs;
    }

    public double getResult(double money)
    {
        return cs.acceptCash(money);
    }
}

接着是客户端代码也需要改动：

void OnClick()
{
    CashContext cc = null;
    switch(“打折类型”)
    {
        case “正常收费”:
            cc = new CashContext(new CashNormal());
            break;
        case "打八折":
            cc= new CashContext(new CashRebate("0.8"));
            break;
    }

    return cc.GetResult(originMoney);
}

大功告成！

但是，聪明的你可能又发现了，这样写不就把switch放到客户端了嘛，这和不用设计模式有啥区别？

那么我们再来改进一下吧——让策略模式和简单工厂模式相结合！

我们来修改一下CashContext:

class CashContext
{
    private CashSuper cs;
    public CashContext(string type)
    {
        switch(type)
        {
            case "正常收费":
                cs = new CashNormal();
                break;
            case "打八折":
                cs = new CashRebate();
                break;
        }
    }

    public double getResult(double money)
    {
        return cs.acceptCash(money);
    }
}

肯定又有聪明的同学发现了，这和工厂模式区别大吗？现在又在工厂里使用switch语句了。

确实如此，不过我们可以来看下客户端调用逻辑：

//简单工厂的用法
CashSuper csuper = CashFactory.createCashAccept(type);
... = csuper.getResult(money)

//策略模式和简单工厂结合
CashContext cspuer = new CashContext(type);
... = csuper.getResult(money)

我们的客户端原来需要认识两个类，CashSuper和CashFactory。

但现在只需要认识一个类，CashContext。

这样做降低了耦合，使具体的收费算法彻底与客户端分离。