1、概述
背景
假如某个入驻美团的商家为了促销，设置多种会员优惠，包含超级会员7折、普通会员9折和普通用户没有折扣三种。用户在付款的时候，根据用户的会员等级，就可以知道用户符合哪种折扣策略，进而计算出实付金额。
定义
该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
结构
策略模式的主要角色如下：
- 抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
- 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。
- 环境（Context）类：持有一个策略类的引用，最终给客户端调用。
2、实现思路
某个入驻美团的商家为了促销，设置多种会员优惠，包含超级会员7折、普通会员9折和普通用户没有折扣三种。用户在付款的时候，根据用户的会员等级，就可以知道用户符合哪种折扣策略，进而计算出实付金额。
我们首先看看不使用策略模式的代码：
public enum Grade
{
COMMON_USER, //普通用户
COMMON_MEMBER, //普通会员
SUPER_MEMBER //超级会员
}
class RealAmount
{
public double calculator(double price, Grade grade)
{
double realAmount = 0.0;
if (grade == Grade.COMMON_USER)
{
realAmount = price;
}
else if (grade == Grade.COMMON_MEMBER)
{
realAmount = price * 0.9;
}
else if (grade == Grade.SUPER_MEMBER)
{
realAmount = price * 0.7;
}
else
{
Console.WriteLine("不支持的会员等级");
}
return realAmount;
}
}
class Program
{
static void Main(string[] args)
{
#region 传统方式
RealAmount realAmount = new RealAmount();
Console.WriteLine($"普通会员支付{realAmount.calculator(100, Grade.COMMON_MEMBER)}");
Console.WriteLine($"普通用户支付{realAmount.calculator(100, Grade.COMMON_USER)}");
Console.WriteLine($"超级会员支付{realAmount.calculator(100, Grade.SUPER_MEMBER)}");
#endregion
}
}
=======================================
普通会员支付90
普通用户支付100
超级会员支付70这种写法：
- 违反了单一职责原则：每种会员的计算方式都写在了RealAmount类中；
- 违法了开闭原则：如果又新出了一个会员等级，那么就得修改calculator这个方法。
下面我们使用策略模式实现：
/// <summary>
/// 策略接口
/// </summary>
public interface IStrategy
{
public double calculator(double price);
}
/// <summary>
/// 普通用户策略类
/// </summary>
public class CommonUserStrategy : IStrategy
{
public double calculator(double price)
{
return price;
}
}
/// <summary>
/// 普通会员策略类
/// </summary>
public class CommonMemberStrategy : IStrategy
{
public double calculator(double price)
{
return price * 0.9;
}
}
/// <summary>
/// 超级会员策略类
/// </summary>
public class SuperMemberStrategy : IStrategy
{
public double calculator(double price)
{
return price * 0.7;
}
}
/// <summary>
/// 销售员类
/// </summary>
public class SalesMan
{
private IStrategy _strategy;
public SalesMan(IStrategy strategy)
{
this._strategy = strategy;
}
public double calculator(double price)
{
return this._strategy.calculator(price);
}
}
class Program
{
static void Main(string[] args)
{
#region 策略模式
SalesMan superMember = new SalesMan(new SuperMemberStrategy());
SalesMan commonMember = new SalesMan(new CommonMemberStrategy());
SalesMan commonUser = new SalesMan(new CommonUserStrategy());
Console.WriteLine($"普通会员支付{commonUser.calculator(100)}");
Console.WriteLine($"普通用户支付{commonMember.calculator(100)}");
Console.WriteLine($"超级会员支付{superMember.calculator(100)}");
#endregion
}
}
===============================
普通会员支付100
普通用户支付90
超级会员支付703、优缺点
优点
- 体现了单一职责原则：每个策略类负责实现对应会员等级的计算方法。
- 体遵循了开闭原则：使用了策略模式之后，如果又新出了一个会员等级，只需针对新增的等级实现一个策略类即可，不需要修改原有的代码。
- 避免使用多重条件选择语句（if else），充分体现面向对象设计思想。
缺点
- 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
- 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。
4、使用场景
- 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
- 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
- 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
- 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
- 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。
