标签：
策略模式的用例图
定义一个算法抽象策略类
//抽象算法类
abstract class Strategy
{
//算法方法
public abstract void AlgorithmInterface();
}
通过继承实现具体的算法
//具体算法A
class ConcreteStrategyA : Strategy
{
//算法A实现方法
public override void AlgorithmInterface()
{
Console.WriteLine("算法A实现");
}
}
//具体算法B
class ConcreteStrategyB : Strategy
{
//算法B实现方法
public override void AlgorithmInterface()
{
Console.WriteLine("算法B实现");
}
}
//具体算法C
class ConcreteStrategyC : Strategy
{
//算法C实现方法
public override void AlgorithmInterface()
{
Console.WriteLine("算法C实现");
}
}
//上下文
class Context
{
Strategy strategy;
public Context(Strategy strategy)
{
this.strategy = strategy;
}
//上下文接口
public void ContextInterface()
{
strategy.AlgorithmInterface();
}
}
客户端实现
Context context;
context = new Context(new ConcreteStrategyA());
context.ContextInterface();
context = new Context(new ConcreteStrategyB());
context.ContextInterface();
context = new Context(new ConcreteStrategyC());
context.ContextInterface();
Console.Read();
运行效果
这个是基本的策略模式的应用
在这里我们解决一个问题,超市中卖商品会存在不同的情况,假如现在存在三种情况 原价销售/打八七折销售/满500减100三种营销策略
那么我们考虑可以通过简单工厂类来实现
工厂类定义
//现金收取工厂
class CashFactory
{
//根据条件返回相应的对象
public static CashSuper createCashAccept(string type)
{
CashSuper cs = null;
switch (type)
{
case "正常收费":
cs = new CashNormal();
break;
case "满300返100":
CashReturn cr1 = new CashReturn("300", "100");
cs = cr1;
break;
case "打8折":
CashRebate cr2 = new CashRebate("0.8");
cs = cr2;
break;
}
return cs;
}
收取现金父类
//现金收取父类
abstract class CashSuper
{
//抽象方法：收取现金，参数为原价，返回为当前价
public abstract double acceptCash(double money);
}
继承父类
//正常收费，继承CashSuper
class CashNormal : CashSuper
{
public override double acceptCash(double money)
{
return money;
}
}
//打折收费，继承CashSuper
class CashRebate : CashSuper
{
private double moneyRebate = 1d;
//初始化时，必需要输入折扣率,如八折，就是0.8
public CashRebate(string moneyRebate)
{
this.moneyRebate = double.Parse(moneyRebate);
}
public override double acceptCash(double money)
{
return money * moneyRebate;
}
}
//返利收费，继承CashSuper
class CashReturn : CashSuper
{
private double moneyCondition = 0.0d;
private double moneyReturn = 0.0d;
//初始化时必须要输入返利条件和返利值，比如满300返100，则moneyCondition为300，moneyReturn为100
public CashReturn(string moneyCondition, string moneyReturn)
{
this.moneyCondition = double.Parse(moneyCondition);
this.moneyReturn = double.Parse(moneyReturn);
}
public override double acceptCash(double money)
{
double result = money;
//若大于返利条件，则需要减去返利值
if (money >= moneyCondition)
result = money - Math.Floor(money / moneyCondition) * moneyReturn;
return result;
}
客户端调用如下
//利用简单工厂模式根据下拉选择框，生成相应的对象
CashSuper csuper = CashFactory.createCashAccept(cbxType.SelectedItem.ToString());
double totalPrices = 0d;
//通过多态，可以得到收取费用的结果
totalPrices = csuper.acceptCash(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
lbxList.Items.Add("单价：" + txtPrice.Text + " 数量：" + txtNum.Text + " "
+ cbxType.SelectedItem + " 合计：" + totalPrices.ToString());
lblResult.Text = total.ToString();
还是存在之前研究的问题,假如商家存在其他营销策略时,要修改到工厂类等等
所以我们考虑用策略模式
如下用策略模式实现
//定义一个收费策略Context
class CashContext
{
//声明一个现金收费父类对象
private CashSuper cs;
//设置策略行为，参数为具体的现金收费子类（正常，打折或返利）
public CashContext(CashSuper csuper)
{
this.cs = csuper;
}
//得到现金促销计算结果（利用了多态机制，不同的策略行为导致不同的结果）
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
定义一个结账的抽象类
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 CashRebate(string moneyRebate)
{
this.moneyRebate = double.Parse(moneyRebate);
}
public override double acceptCash(double money)
{
return money * moneyRebate;
}
}
class CashReturn : CashSuper
{
private double moneyCondition = 0.0d;
private double moneyReturn = 0.0d;
public CashReturn(string moneyCondition,string moneyReturn)
{
this.moneyCondition = double.Parse(moneyCondition);
this.moneyReturn = double.Parse(moneyReturn);
}
public override double acceptCash(double money)
{
double result = money;
if (money >= moneyCondition)
result=money- Math.Floor(money / moneyCondition) * moneyReturn;
return result;
}
}
客户端调用情况如下
CashContext cc = null;
switch (cbxType.SelectedItem.ToString())
{
case "正常收费":
cc = new CashContext(new CashNormal());
break;
case "满300返100":
cc = new CashContext(new CashReturn("300", "100"));
break;
case "打8折":
cc = new CashContext(new CashRebate("0.8"));
break;
}
double totalPrices = 0d;
totalPrices = cc.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
这样如果商家再加上某种活动可以在客户端进行处理,判断条件就放到了客户端调用这边.
策略模式和简单工厂模式的结合--和上面的只是客户端调用和context存在差异
//现金收取工厂
class CashContext
{
CashSuper cs = null;
//根据条件返回相应的对象
public CashContext(string type)
{
switch (type)
{
case "正常收费":
CashNormal cs0 = new CashNormal();
cs = cs0;
break;
case "满300返100":
CashReturn cr1 = new CashReturn("300", "100");
cs = cr1;
break;
case "打8折":
CashRebate cr2 = new CashRebate("0.8");
cs = cr2;
break;
}
}
public double GetResult(double money)
{
return cs.acceptCash(money);
}
}
客户端调用
CashContext csuper = new CashContext(cbxType.SelectedItem.ToString());
double totalPrices = 0d;
//通过多态，可以得到收取费用的结果
totalPrices = csuper.GetResult(Convert.ToDouble(txtPrice.Text) * Convert.ToDouble(txtNum.Text));
total = total + totalPrices;
标签：
原文地址：http://www.cnblogs.com/sdya/p/5263822.html
