设计模式笔记2：策略模式

1.1  需求

　　设计一个商场打折计费的软件，可以实现打折，满300送100等优惠功能。

1.2 类图

　　

1.3　　实现

　　我们先把4个计算的类写出来。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 策略模式
{
    // 核心类，定义了具体实现功能。算法的不同实现由各个类来完成。
    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 rebate = 1.0d;
        public CashRebate(double rebate)
        {
            this.rebate = rebate;
        }
        public override double AcceptCash(double money)
        {
            return this.rebate * money;
        }
    }

    class CashReturn : CashSuper
    {
        private double moneyCondition;
        private double moneyReturn;

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

        public override double AcceptCash(double money)
        {
            return money - (int)(money / this.moneyCondition) * this.moneyReturn;
        }
    }



}

　　在写负责创建对象和调用的CashCoxt类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 策略模式
{
    class CashContext
    {
        private CashSuper cs;
        // 运用到了简单工厂，根据条件创建指定对象。可用发射优化。
        public CashContext(string type)
        {
            switch (type)
            {
                case "不打折": cs = new CashNormal();
                    break;
                case "九折": cs = new CashRebate(0.9d);
                    break;
                case "五折": cs = new CashRebate(0.5d);
                    break;
                case "满300返100": cs = new CashReturn(300, 100);
                    break;
            }
        }

        public double GetResult(double money)
        {
            return cs.AcceptCash(money);
        }

    }
}

　　

　　最后调用的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 策略模式
{
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                Console.WriteLine("请输入金额：");
                double money = double.Parse(Console.ReadLine());
                Console.WriteLine("请选择打折方式：1.不打折    2.九折    3.五折    4.满300返100");
                int index = int.Parse(Console.ReadLine()) - 1;
                string type = new String[] { "不打折", "九折", "五折", "满300返100" }[index];
                // 计算价格
                Console.WriteLine("你需要付款：" + new CashContext(type).GetResult(money));
                Console.ReadKey(true);
            }



        }
    }
}

1.4　　总结

 

　　我们客户端的代码只用到了CashContext类，降低了耦合。 而策略模式的精髓在于：完成同一个功能有不同的算法时，我们把他抽象到父类。然后每一个功能都由对应的子类来实现。 再用一个中间类为我们创建对象，调用方法。

　　这样的2点好处：　　  

　　　　1、减少了各种算法类之间的耦合。

　　　　2、优化了单元测试。

　　策略模式就是用来封装算法的，当我们实践中某一个功能有多种实现的算法。我们就可以考虑使用策略模式。