设计模式之策略模式及（策略+⼯⼚）结合使⽤
定义：策略模式定义了⼀系列的算法，并将每⼀个算法封装起来，⽽且使他们可以相互替换，让算法独⽴于使⽤它的客户⽽独⽴变化
分析下定义，策略模式定义和封装了⼀系列的算法，它们是可以相互替换的，也就是说它们具有共性，⽽它们的共性就体现在策略接⼝的⾏为上，另外为了达到最后⼀句话的⽬的，也就是说让算法独⽴于使⽤它的客户⽽独⽴变化，我们需要让客户端依赖于策略接⼝
策略模式的使⽤场景：策略模式定义了⼀系列的算
1.针对同⼀类型问题的多种处理⽅式，仅仅是具体⾏为有差别时；
2.需要安全地封装多种同⼀类型的操作时；
3.出现同⼀抽象类有多个⼦类，⽽⼜需要使⽤ if-else 或者 switch-case 来选择具体⼦类时。
这个模式涉及到三个⾓⾊：
环境(Context)⾓⾊：持有⼀个Strategy的引⽤。
抽象策略(Strategy)⾓⾊：这是⼀个抽象⾓⾊，通常由⼀个接⼝或抽象类实现。此⾓⾊给出所有的具体策略类所需的接⼝。
具体策略(ConcreteStrategy)⾓⾊：包装了相关的算法或⾏为。
策略模式的典型代码如下：
抽象策略类
public interface Strategy {
/**
* 策略⽅法
*/
public void strategyInterface();
}
具体策略类
public class ConcreteStrategyA implements Strategy {
@Override
public void strategyInterface() {
//相关的业务
}
}
public class ConcreteStrategyB implements Strategy {
@Override
public void strategyInterface() {
/
/相关的业务
}
}
环境⾓⾊类
public class Context {
//持有⼀个具体策略的对象
private Strategy strategy;
/**
* 构造函数，传⼊⼀个具体策略对象
* @param strategy    具体策略对象
*/
public Context(Strategy strategy){
this.strategy = strategy;
}
/**
* 策略⽅法
*/
public void contextInterface(){
strategy.strategyInterface();
}
}
策略模式例⼦
假设鹅⼚推出了3种会员，分别为会员，超级会员以及⾦牌会员，还有就是普通玩家，针对不同类别的玩家，购买《王者农药》⽪肤有不同的打折⽅式，并且⼀个顾客每消费10000就增加⼀个级别，那么我们就可以使⽤策略模式，因为策略模式描述的就是算法的不同，这⾥我们举例就采⽤最简单的，以上四种玩家分别采⽤原价（普通玩家），九折，⼋折和七价的收钱⽅式。
那么我们⾸先要有⼀个计算价格的策略接⼝
public interface CalPrice {
//根据原价返回⼀个最终的价格
Double calPrice(Double orgnicPrice);
}
下⾯是4种玩家的计算⽅式的实现
public class Orgnic implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice;
}
}
public class Vip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.9;
}
}
public class SuperVip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.8;
}
}
public class GoldVip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.7;
}
}
我们看客户类，我们需要客户类帮我们完成玩家升级的功能。
public class Player {
private Double totalAmount = 0D;//客户在鹅⼚消费的总额
private Double amount = 0D;//客户单次消费⾦额
private CalPrice calPrice = new Orgnic();//每个客户都有⼀个计算价格的策略，初始都是普通计算，即原价
//客户购买⽪肤，就会增加它的总额
public void buy(Double amount) {
this.amount = amount;
totalAmount += amount;
if (totalAmount > 30000) {//30000则改为⾦牌会员计算⽅式
calPrice = new GoldVip();
} else if (totalAmount > 20000) {//类似
calPrice = new SuperVip();
} else if (totalAmount > 10000) {//类似
calPrice = new Vip();
}
}
//计算客户最终要付的钱
public Double calLastAmount() {
return calPrice.calPrice(amount);
}
}
接下来是客户端调⽤，系统会帮我们⾃动调整收费策略。
public class Client {
public static void main(String[] args) {
Player player = new Player();
player.buy(5000D);
System.out.println("玩家需要付钱：" + player.calLastAmount());
player.buy(12000D);
System.out.println("玩家需要付钱：" + player.calLastAmount());
player.buy(12000D);
System.out.println("玩家需要付钱：" + player.calLastAmount());
player.buy(12000D);
System.out.println("玩家需要付钱：" + player.calLastAmount());
}
}
运⾏以后会发现，第⼀次是原价，第⼆次是九折，第三次是⼋折，最后⼀次则是七价。这样设计的好处是，客户不再依赖于具体的收费策略，依赖于抽象永远是正确的。
在上⾯的基础上，我们可以使⽤简单⼯⼚来稍微进⾏优化
public class CalPriceFactory {
private CalPriceFactory(){}
//根据客户的总⾦额产⽣相应的策略
public static CalPrice createCalPrice(Player customer){
if (TotalAmount() > 30000) {//3000则改为⾦牌会员计算⽅式
return new GoldVip();
}else if (TotalAmount() > 20000) {//类似
return new SuperVip();
}else if (TotalAmount() > 10000) {//类似
return new Vip();
}else {
return new Orgnic();
}
}
}
这样就将制定策略的功能从客户类分离了出来，我们的客户类可以变成这样。
public class Player {
private Double totalAmount = 0D;//客户在鹅⼚消费的总额
private Double amount = 0D;//客户单次消费⾦额
private CalPrice calPrice = new Orgnic();//每个客户都有⼀个计算价格的策略，初始都是普通计算，即原价
//客户购买⽪肤，就会增加它的总额
public void buy(Double amount) {
this.amount = amount;
totalAmount += amount;
/* 变化点，我们将策略的制定转移给了策略⼯⼚，将这部分责任分离出去 */
calPrice = ateCalPrice(this);
}
//计算客户最终要付的钱
public Double calLastAmount() {
return calPrice.calPrice(amount);
}
抽象类的使用public Double getTotalAmount() {
return totalAmount;
}
}
虽然结合简单⼯⼚模式，我们的策略模式灵活了⼀些，但不免发现在⼯⼚中多了if-else判断，也就是如果增加⼀个会员类别，我⼜得增加⼀个else-if语句，这是简单⼯⼚的缺点，对修改开放。
那有什么⽅法，可以较好的解决这个问题呢？那就是使⽤注解， 所以我们需要给注解加⼊属性上限和下限，⽤来表⽰策略⽣效的区间，⽤来解决总⾦额判断的问题。
1.⾸先我们做⼀个注解，这个注解是⽤来给策略添加的，当中可以设置它的上下限
//这是有效价格区间注解，可以给策略添加有效区间的设置
@Target(ElementType.TYPE)//表⽰只能给类添加该注解
@Retention(RetentionPolicy.RUNTIME)//这个必须要将注解保留在运⾏时
public @interface PriceRegion {
int max() default Integer.MAX_VALUE;
int min() default Integer.MIN_VALUE;
}
可以看到，我们只是使⽤这个注解来声明每⼀个策略的⽣效区间，于是对策略进⾏修改
@PriceRegion(max = 10000)
public class Orgnic implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice;
}
}
@PriceRegion(max=20000)
public class Vip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.9;
}
}
@PriceRegion(min=20000,max=30000)
public class SuperVip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.8;
}
}
@PriceRegion(min=3000)
public class GoldVip implements CalPrice {
@Override
public Double calPrice(Double orgnicPrice) {
return orgnicPrice * 0.7;
}
}
接下来就是在策略⼯⼚中去处理注解
public class CalPriceFactory {
private static final String CAL_PRICE_PACKAGE = "ample.stragedemo";//这⾥是⼀个常量，表⽰我们扫描策略的包
private ClassLoader classLoader = getClass().getClassLoader();

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。