先不管模式, 把他和他的名字都忘了, 来看看问题 和 设计思路. 为啥要这么做.
场景:有一家店铺, 里面有一个售货员, 售货员当然是要卖东西的啦, 客户进来买完东西, 找售货员结账, 那售货员得知道一共多少钱吧?
一. 初步设计
商品类:
我要评论package org.elvin.strategy;
/***/
public class Goods {
/**
* 商品名
*/
private String name;
/**
* 商品价格
*/
private Long Price;
public Goods() { }
public Goods(String name, Long price) {
this.name = name;
Price = price;
}
//region getter / setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getPrice() {
return Price;
}
public void setPrice(Long price) {
Price = price;
}
//endregion
}
由于价格我使用的是 Long 类型, 所以, 要有一个转换输出的方法.
package org.elvin.strategy;
import java.text.MessageFormat;
public class MoneyUtils {
public static String getYuan(Long money){
Long yuan = money / 100;
Long jiao = money % 100 / 10;
Long fen = money % 10;
return MessageFormat.format("{0}.{1}{2}", yuan, jiao , fen );
}
}
售货员:
package org.elvin.strategy;
import org.elvin.strategy.calculator.*;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
/**
* 环境角色(Context)*/
public class Seller {
/**
* 姓名
*/
private String name;
/**
* 编号
*/
private String code;
//region getter / setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
//endregion
/**
* 售卖商品
*/
public void sellGoods(List<Goods> goods){
Long sum = 0L;
for (Goods good : goods) {
sum += good.getPrice();
}
System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元");
}
@Test
public void func1(){
List<Goods> goods = new ArrayList<>();
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("饼干", 250L));
goods.add(new Goods("辣条", 300L));
sellGoods(goods);
}
}
来看一下计算结果:
得到结果了, 没啥毛病, 挺好.
今天老板过生日, 突然想到, 要不要再店里搞个活动, 来个优惠活动, 有些商品减价销售.
明天老板娘过生日, 老板娘说, 老娘高兴, 你减价销售, 明天我来个免单销售.
那现在咋办呢? 明天过后, 价格肯定又要恢复到正常价格. what the fuck!
Seller类写死了, 难道我在里面加几个计算方法?
加进去貌似可以解决当下问题, 但是, 后天如果老板的老丈人过生日呢? 咋搞?
Ok, 到这里, 差不多, 需要请出今天的大神 : 策略模式. 让他来帮我们解决这个问题吧.
二. 设计改造
对于售货员来说, 她必须知道, 今天该怎么计算价格, 是优惠还是不优惠, 或者是满多少钱, 送东西什么的.
那么, 将这些优惠或者说价格的计算方法抽象出来, 成为一个接口或者抽象类.
让优惠或者不优惠实现或者继承他.
实现方式:
这里, 我将他抽象为一个接口
package org.elvin.strategy.calculator; import org.elvin.strategy.Goods; import java.util.List; /** * 抽象策略角色(Strategy) * 优惠接口
*/ public interface PreferentialPrice { public void getPrice(List<Goods> goods); }
PreferentialPrice 需要作为一个属性,出现在 Seller 类中.
在Seller中加入
/**
* 计算优惠后的价格
* 抽象角色, 次角色给出所有具体策略类所需的接口
*/
private PreferentialPrice preferentialPrice;
public PreferentialPrice getPreferentialPrice() {
return preferentialPrice;
}
public void setPreferentialPrice(PreferentialPrice preferentialPrice) {
this.preferentialPrice = preferentialPrice;
}
这里提供三种计算方式:
1. 正常方式
/** * 具体策略角色(ConcreteStrategy)
*/ public class NoPreferential implements PreferentialPrice { @Override public void getPrice(List<Goods> goods) { Long sum = 0L; for (Goods good : goods) { sum += good.getPrice(); } System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元"); } }
2. 免单方式
/** * 具体策略角色(ConcreteStrategy)
*/ public class Free implements PreferentialPrice { @Override public void getPrice(List<Goods> goods) { System.out.println("免单, 不要钱 !"); } }
3. 部分优惠方式
/** * 具体策略角色(ConcreteStrategy)
*/ public class ReduceSomeGoods implements PreferentialPrice { @Override public void getPrice(List<Goods> goods) { Long sum = 0L; for (Goods good : goods) { switch (good.getName()) { case "泡面": sum += good.getPrice() - 50L; break; case "火腿": sum += good.getPrice() - 20L; break; case "鸡蛋": sum += good.getPrice() - 10L; break; default: sum += good.getPrice(); break; } } System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元"); } }
将Seller类中, 计算的方法修改一下:
public void sellGoods(List<Goods> goods){
if(preferentialPrice == null){
setPreferentialPrice(new NoPreferential());
}
preferentialPrice.getPrice(goods);
}
在计算的时候, 如果没有传入优惠, 则默认使用无优惠方式
再看测试方法:
@Test
public void func1(){
List<Goods> goods = new ArrayList<>();
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("泡面", 550L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("火腿", 150L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("鸡蛋", 70L));
goods.add(new Goods("饼干", 250L));
goods.add(new Goods("辣条", 300L));
setPreferentialPrice(new Free());
sellGoods(goods);
System.out.println("-----------------------");
setPreferentialPrice(new ReduceSomeGoods());
sellGoods(goods);
System.out.println("-----------------------");
setPreferentialPrice(new NoPreferential());
sellGoods(goods);
}
结果:
策略模式作为一种对象行为模式, 在这里应该还是体现到了吧.
那总结一下?给个不容易懂得(网上抄的):
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。
说的比较抽象, 来个具体的吧:
一帅哥喜欢约妹子, 那咋约出来呢? 不是所有的妹子都喜欢吃饭看电影吧. 那针对不同的妹子, 使用不同的方法来约. 约喜欢看电影的妹子看电影, 约喜欢吃小吃的妹子吃小吃.
那吃饭, 看电影, 吹海风...... 等等, 这些手段, 目的都是为了让妹子做他女朋友(这里不讨论时间). 目的不变, 手段层出不穷. 这些方法, 就可以理解为不同的 strategy.
通过上面的例子, 可以看出, 具体的算法与算法之间没有依赖关系, 都是平等的(平等性), 可以相互替换的. 那在运行的时候, 每次都只能使用一种(唯一性).
如对本文有疑问， 点击进行留言回复！！
荐 厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略
FlowableException: Error initialising dmn data model报错问题
网友评论