有这样一种情况,一个商场举行活动,进行促销,开始一段时间采取的是打折的方式,假设打9折,如果要编这样
的一个程序,想必是非常简单的。后来老板发现现有的促销方式无法燃起消费者的购物欲,决定加大打折力度,采
取了满400立减100的策略,编程实现的话,可能就加个判断语句以及一些代码就行。后来促销结束,返回原价,为了
保障系统正常运行,又加了一个判断以及部分代码。
很明显,如果按照上面的方式去写程序,维护起来非常困难,功能之间的冗余度非常的高。
这时,就引入了策略模式(Strategy)
策略模式定义了某一个算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化,不会影响到使用
该算法的客户。
先看它的类图:
①:策略模式定义了一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,他可以
以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合。
②:另一方面,策略模式的Strategy类层次为Context定义了一些列的可重用的算法或者行为,继承有助于折取这些算法中
的公共功能。
③:还有就是,策略模式简化了单元测试,因为每个类都有自己的类,可以通过自己的接口单独测试。
接下来看实现代码:
CashSuper类:
package com.blog.anla.Strategy;
/**
* 策略模式,策略的公共父类
* 策略模式和简单工厂模式不同,前者注重不同的算法
* 而后者助攻的产生哪一个对象
* @author U-ANLA
*
*/
public abstract class CashSuper {
/**
* 抽象的策略方法
*/
public abstract int acceptCash(int money);
}
package com.blog.anla.Strategy;
/**
* 策略之一
* 按原价收费
* @author U-ANLA
*
*/
public class CashNormal extends CashSuper{
@Override
public int acceptCash(int money) {
return money;
}
}
package com.blog.anla.Strategy;
/**
* 策略之二
* 打折的策略算法
* @author U-ANLA
*
*/
public class CashRebate extends CashSuper{
private float level;
public CashRebate(int level){
this.level = level;
}
@Override
public int acceptCash(int money) {
return (int)(money*level);
}
}
package com.blog.anla.Strategy;
/**
* 策略之三
* 职责是满减活动
* @author U-ANLA
*
*/
public class CashReturn extends CashSuper{
private int threshold;
private int reduction;
public CashReturn(int threshold,int reduction){
this.threshold = threshold;
this.reduction = reduction;
}
@Override
public int acceptCash(int money) {
if(money < threshold){
return money;
}else{
return money - reduction;
}
}
}
package com.blog.anla.Strategy;
/**
* 维护对具体CashSuper的策略的引用
* @author U-ANLA
*
*/
public class CashContext {
private CashSuper cs = null;
public CashContext(CashSuper cs){
this.cs = cs;
}
public int getResult(int money){
return cs.acceptCash(money);
}
}
赠人玫瑰手留余香,共勉哈
设计模式相关代码以及类图的整个项目都托管到了github上,包括各个模式的示例
代码以及类图,类图则用的visio绘制,整个visio文件也在该项目上,这里贴上地址:
https://github.com/anLA7856/design
如果觉得有帮助,start一下呗~我会非常开心的