设计模式-策略模式

定义策略模式实际上是定义了一系列算法，他们可以相互替换，但是并不影响算法的调用者。
类型行为型模式
特点算法可以相互替换，并不相互影响，具体算法也不会暴露给调用者。
举例超市结账时，使用不同的优惠方式进行结算。

本文以C#为例，先来看类图🔻

设计模式-策略模式.jpg CashContext主要用于维护一个策略对象。 CashNormal（正常结算）、CashDiscount（折扣结算）、StrategyReturn（满减结算）均继承自CashStrategy，代表具体的策略实现。

这个时候如果又需要开发一个新的结算策略时，只需要继承抽象策略，然后实现新的算法即可。

下面我们来看具体的代码实现🔻

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


    /// <summary>
    /// 策略上下文
    /// </summary>
    public class CashContext
    {
        private readonly CashStrategy _cashStrategy;
        public CashContext(CashStrategy cashStrategy)
        {
            _cashStrategy = cashStrategy;
        }

        public double GetResult(double money)
        {
            return _cashStrategy.DoCalc(money);
        }
    }

1
2
3
4
5
6
7


    /// <summary>
    /// 抽象策略
    /// </summary>
    public abstract class CashStrategy
    {
        public abstract double DoCalc(double money);
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


    /// <summary>
    /// 正常结算策略
    /// </summary>
    public class CashNormal : CashStrategy
    {
        public override double DoCalc(double money)
        {
            //正常结算，不做任何计算
            return money;
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


    /// <summary>
    /// 折扣结算策略
    /// </summary>
    public class CashDiscount : CashStrategy
    {
        //要使用的折扣
        private readonly double _discount;
        public CashDiscount(double discount)
        {
            _discount = discount;
        }
        public override double DoCalc(double money)
        {
            //折扣结算
            return money * _discount;
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


    /// <summary>
    /// 满减结算策略
    /// </summary>
    public class StrategyReturn : CashStrategy
    {
        //满减配置，例如：满200减30
        private readonly double _fullMoney;
        private readonly double _returnMoney;
        public StrategyReturn(double fullMoney, double returnMoney)
        {
            _fullMoney = fullMoney;
            _returnMoney = returnMoney;
        }
        public override double DoCalc(double money)
        {
            //满减计算
            if (money < _fullMoney)
            {
                return money;
            }
            return money - _returnMoney;
        }
    }

实际调用🔻

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


            double money = 100;
            double payment;
            Console.WriteLine($"本次消费金额{money}元");
            Console.WriteLine(System.Environment.NewLine);

            var normalContext = new CashContext(new CashNormal());
            payment = normalContext.GetResult(money);
            Console.WriteLine($"正常结算策略，本次需要付款{payment}元");
            Console.WriteLine(System.Environment.NewLine);

            //折扣
            double discount = 0.8;
            var discountContext = new CashContext(new CashDiscount(discount));
            payment = discountContext.GetResult(money);
            Console.WriteLine($"折扣结算策略，折扣{discount}，本次需要付款{payment}元");
            Console.WriteLine(System.Environment.NewLine);

            //满100-50
            double fullMoney = 100;
            double returnMoney = 50;
            var returnContext = new CashContext(new StrategyReturn(fullMoney, returnMoney));
            payment = returnContext.GetResult(money);
            Console.WriteLine($"满减结算策略，满{fullMoney}减{returnMoney}，本次需要付款{payment}元");
            Console.WriteLine(System.Environment.NewLine);

            Console.ReadLine();

运行结果🔻

参考资料：
《大话设计模式》

文章目录