深入浅出设计模式系列（二）：策略模式

端午节到了，Jacky在家没事做，就跑去自己学长Cook的家串门。两个人聊得甚欢，Cook突然兴起，说，Jacky，今天我让你做个程序题，你想不想做。踌躇满志想成为一个优秀的程序员的Jacky当然毫不犹豫的就答应了。

Jacky：来吧，什么题目啊？没有难度的题目可别出哦！

Cook：你小子，长成了是吧？别看到时候出的题目简单，里面学问可不少呢。

Jacky：好吧，那你就别废话了，快说什么题目？

Cook：嗯，是这样的，就做一个商场的收营程序，程序要记录买的商品单价、商品数量，商品价格并且计算出商品的总价。

Jacky：就这个啊？那还不容易啊？不就是在一个窗体上放两个文本框分别用来填写商品单价、商品数量，然后用一个列表框来记录商品的清单，一个标签来记录总计，一个确定按钮来算出每种商品的费用。对了，还要一个重置按钮，来重新开始。

说着Jacky就去写代码了，不一会儿，半小时不到代码就写好了。他是这么写的

private void btnOK_Click(object sender, EventArgs e)
{
    double total = 0.0d;

    double totalPrice = Convert.ToDouble(txtProductNumber.Text) * Convert.ToDouble(txtProductUnitPrice.Text);

    total += totalPrice;

    lvProducts.Items.Add("商品数量：" + txtProductNumber.Text + " 商品单价：" + txtProductUnitPrice.Text + " 商品总价：" + totalPrice.ToString());

    lblTotal.Text += total.ToString();
}

Cook看了看Jacky写的代码，摇了摇头对Jacky说

Cook：你看看，你这么写的话，如果我要现在又有一个新的需求，商店端午小长假促销活动，所有商品打8折，那你要怎么办啊？

Jacky：那也很简单啊，只有修改一行代码就行了啊，只要把代码改成下面那样就Ok了,这样就是打八折了。

double totalPrice = Convert.ToDouble(txtProductNumber.Text) * Convert.ToDouble(txtProductUnitPrice.Text) * 0.8;

Cook：那如果端午节过了呢？不打折了，你这套程序岂不是会让商场蒙受巨大的损失啊？

Jacky：那么到时候不打折了，我再把程序改回来就OK了啊。

Cook：现在一年四季那么多节日，打折促销活动又层出不穷的。一会儿打折让利，一会儿满300返100的活动让利，又一会儿消费满200积分50的活动，轮番上阵，那你岂不是得累死啊？跟着他们不停的修改程序，部署客户端，这样你不觉得麻烦吗？你不觉得麻烦，人家商场的领导都觉得麻烦了。

Jacky：啊。。。我好像是想的有些太简单了。那要不我增加一个下拉框，添加一些既定的打着方式，到时候让他们营业员来选择，这样就可以省掉一些麻烦事了。

就这样，Jacky又跑回电脑旁去改写自己刚才的程序，添加了一个让利下拉框，供客户程序进行选择。他是这么写的

private void btnOK_Click(object sender, EventArgs e)
{
    double total = 0.0d;
    double totalPrice = 0.0d;

    switch (cmbType.SelectedText)
    {
        case "正常收费":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice);
            break;
        case "五折":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) * 0.5;
            break;
        case "六折":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) * 0.6;
            break;
        case "七折":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) * 0.7;
            break;
        case "八折":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) * 0.8;
            break;
        case "满300减100":
            totalPrice = Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) - Math.Floor(Convert.ToDouble(txtProductNumber) * Convert.ToDouble(txtProductUnitPrice) / 300) * 100;
            break;
        default:
            break;
    }

    total += totalPrice;

    lvProducts.Items.Add("商品数量：" + txtProductNumber.Text + " 商品单价：" + txtProductUnitPrice.Text + " 商品总价：" + totalPrice.ToString());

    lblTotal.Text += total.ToString();
}

Jacky兴高采烈的跑去让Cook看他改进后的代码

Jacky：Cook，你快来，快来帮我看看，我把程序改进过了。

Cook：嗯，我看看，哦，这样子写的确是比先前的代码要灵活些了。不过还是不够好，你看看你的代码，打5折和打6折，7折，8折有什么区别？就是最后的乘数不同，你干嘛要写那么多重复的代码？看看能不能进行封装一下啊？看来我之前教你的，都白教了，你都给忘记了。

Jacky：哦哦，对哦，这个可以使用简单工厂方式，是吧？

一溜烟，Jacky又跑去电脑边写起了代码，很快他就写好了代码，拿来给Cook看，他是这么写的

//抽象产品类
public abstract class CashSuper
{
    public abstract double AcceptCash(double money);
}

//正常收费产品类
public class CashNomal : CashSuper
{
    public override double AcceptCash(double money)
    {
        return money;
    }
}

//打折产品类
public class CashDiscount : CashSuper
{
    public double Rate { get; set; }

    public CashDiscount(double rate)
    {
        this.Rate = rate;
    }

    public override double AcceptCash(double money)
    {
        return money * Rate;
    }
}

//返现产品类
public class CashBack : CashSuper
{
    public double CashBackCondition { get; set; }
    public double BackMoney { get; set; }

    public CashBack(double cashBackCondition, double backMoney)
    {
        this.CashBackCondition = cashBackCondition;
        this.BackMoney = backMoney;
    }

    public override double AcceptCash(double money)
    {
        return money - (money / CashBackCondition) * BackMoney;
    }
}

//工厂类
public class PayMoneyFactory
{
    public static CashSuper CreateAcceptCash(string payType)
    {
        CashSuper cashSuper = null;

        switch (payType)
        {
            case "正常收费":
                cashSuper = new CashNomal();
                break;
            case "五折":
                cashSuper = new CashDiscount(0.5);
                break;
            case "六折":
                cashSuper = new CashDiscount(0.6);
                break;
            case "七折":
                cashSuper = new CashDiscount(0.7);
                break;
            case "八折":
                cashSuper = new CashDiscount(0.8);
                break;
            case "满300减100":
                cashSuper = new CashBack(300, 100);
                break;
            case "满200减50":
                cashSuper = new CashBack(200, 50);
                break;
        }

        return cashSuper;
    }
}

//客户端代码
private void btnOK_Click(object sender, EventArgs e)
{
    double total = 0.0d;
    double totalPrice = 0.0d;

    CashSuper cashSuper = PayMoneyFactory.CreateAcceptCash(cmbType.SelectedText);

    totalPrice = cashSuper.AcceptCash(Convert.ToDouble(txtProductNumber.Text) * Convert.ToDouble(txtProductUnitPrice.Text));            

    total += totalPrice;

    lvProducts.Items.Add("商品数量：" + txtProductNumber.Text + " 商品单价：" + txtProductUnitPrice.Text + " 商品总价：" + totalPrice.ToString());

    lblTotal.Text += total.ToString();
}

Cook：嗯，我看看代码，Jacky写的不错啊，有长进，看来现在你对简单工厂模式掌握的不错啊。。。

Jacky：那是当然的，你也不看看我是谁？

Cook：好了，别又得意忘形了。简单工厂模式虽然也能解决这个问题，但这个模式只能解决对象的创建问题，而且由于工厂本身包括了所有的收费方式，商场可能经常性的更改打折额度，每次维护和扩展收费方式都要改动这个工厂，以致于代码需要重新编译部署，这真是很糟糕的处理方式，所以用它不是最好的办法。面对算法的时常变动，应该可以有更好的办法。今天我就教你一个新招。

Jacky：又是什么新招？什么设计模式？你就别再卖关子了，快告诉我吧。

Cook：嗯，那就是策略模式。来，看我来给你写代码。

//抽象策略角色
public abstract class CashSuper
{
    public abstract double AcceptCash(double money);
}

//正常收费策略
public class CashNomal : CashSuper
{
    public override double AcceptCash(double money)
    {
        return money;
    }
}

//打折策略
public class CashDiscount : CashSuper
{
    public double Rate { get; set; }

    public CashDiscount(double rate)
    {
        this.Rate = rate;
    }

    public override double AcceptCash(double money)
    {
        return money * Rate;
    }
}

//返现策略
public class CashBack : CashSuper
{
    public double CashBackCondition { get; set; }
    public double BackMoney { get; set; }

    public CashBack(double cashBackCondition, double backMoney)
    {
        this.CashBackCondition = cashBackCondition;
        this.BackMoney = backMoney;
    }

    public override double AcceptCash(double money)
    {
        return money - (money / CashBackCondition) * BackMoney;
    }
}

//环境角色，上下文，持有一个策略类的引用，供最终给客户端调用
public class CashContext
{
    private CashSuper cashSuper = null;

    public CashContext(string payType)
    {
        switch (payType)
        {
            case "正常收费":
                cashSuper = new CashNomal();
                break;
            case "五折":
                cashSuper = new CashDiscount(0.5);
                break;
            case "六折":
                cashSuper = new CashDiscount(0.6);
                break;
            case "七折":
                cashSuper = new CashDiscount(0.7);
                break;
            case "八折":
                cashSuper = new CashDiscount(0.8);
                break;
            case "满300减100":
                cashSuper = new CashBack(300, 100);
                break;
            case "满200减5100":
                cashSuper = new CashBack(200, 50);
                break;
        }
    }

    public double GetPayResult(double money)
    {
        return cashSuper.AcceptCash(money);
    }
}

//客户端代码
private void btnOK_Click(object sender, EventArgs e)
{
    double total = 0.0d;
    double totalPrice = 0.0d;

    CashContext context = new CashContext(cmbType.SelectedText);
    totalPrice = context.GetPayResult(Convert.ToDouble(txtProductNumber.Text) * Convert.ToDouble(txtProductUnitPrice.Text));

    total += totalPrice;

    lvProducts.Items.Add("商品数量：" + txtProductNumber.Text + " 商品单价：" + txtProductUnitPrice.Text + " 商品总价：" + totalPrice.ToString());

    lblTotal.Text += total.ToString();
}

Cook：看像这样商场收营如何促销，是打折还是返利，其实都是一些算法，算法本身只是一个策略，最重要这些算法随时都可能互相替换的，这就是变化点，封装变化点就是我们面向对象的一种重要的思维方式。这里有一个抽象类，这个抽象类定义了一个获取收营金额的方法，然后不同的策略算法类来继承自这个抽象类，实现这个抽象类的抽象方法计算收营金额，在CashContext类中，维护一个收营的父类对象，根据收营方式的不同，动态的调用不同策略类计算收营的方法。

策略模式（Strategy Pattern）

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。（原文：The Strategy Pattern defines a family of algorithms,encapsulates each one,and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.）

Context(应用场景):

1. 需要使用ConcreteStrategy提供的算法。 
2. 内部维护一个Strategy的实例。 
3. 负责动态设置运行时Strategy具体的实现算法。 
4. 负责跟Strategy之间的交互和数据传递。 

Strategy(抽象策略类)： 

1. 定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。 

ConcreteStrategy(具体策略类)： 

1. 实现了Strategy定义的接口，提供具体的算法实现。

策略模式的组成

• 抽象策略角色： 策略类，通常由一个接口或者抽象类实现。 
• 具体策略角色：包装了相关的算法和行为。 
• 环境角色：持有一个策略类的引用，最终给客户端调用。

策略模式的应用场景 

1. 多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。(例如FlyBehavior和QuackBehavior) 
2. 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。(例如FlyBehavior和QuackBehavior的具体实现可任意变化或扩充) 
3. 对客户(Duck)隐藏具体策略(算法)的实现细节，彼此完全独立。

 

策略模式的优点

• 提供了一种替代继承的方法，而且既保持了继承的优点(代码重用)还比继承更灵活(算法独立，可以任意扩展)。 
• 避免程序中使用多重条件转移语句，使系统更灵活，并易于扩展。 
• 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。 

 

策略模式的缺点

• 由于每个具体策略类都会产生一个新类，所以会增加系统需要维护的类的数量

文章声明：本文部分内容参考自《大话设计模式》,这是一本学习设计模式非常好的书。