在实际开发中，可能会遇到这样一个情况，某一功能的实现分为多种算法，这些算法能够认定为策略，在实际操作时选择不同算法或策略进行操作得出终于结果。在实际生活中。这些样例也是举不胜举。比如。商场举行活动，满100元减10元，满200元减30元，满500元减100元等等...这样每消费一笔，依据这一笔钱消费的多少。计算终于应支付的钱相应着不同的算法，这些相应的不同计算方法就能够认定为是不同的策略。
在某东购物时，依据不同的用户等级，打折力度也是不同的。
策略模式的UML类图參照下图：
假如没有策略模式。实现某东购物计算终于付款的方法如何呢？
package com.strategy.demo;
public class NoStrategy {
/**
* 不使用測量模式实现
* @param args
*/
private static final int NOCARDUSER=1;
private static final int IRONCARDUSER=2;
private static final int GOLDCARDUSER=3;
public static void main(String[] args) {
NoStrategy NoStrategy1=new NoStrategy();
NoStrategy NoStrategy2=new NoStrategy();
NoStrategy NoStrategy3=new NoStrategy();
System.out.println("没有卡牌的买家买100元货物终于应付款："+NoStrategy1.getPrice(100.0, 1));
System.out.println("铁牌的买家买100元货物终于应付款："+NoStrategy2.getPrice(100.0, 2));
System.out.println("金牌的买家买100元货物终于应付款："+NoStrategy3.getPrice(100.0, 3));
}
private double getNoCardPrice(double price){
return price;
}
private double getIronCardPrice(double price){
return price*0.9;
}
private double getGoldCardPrice(double price){
return price*0.7;
}
private double getPrice(double price,int type){
if(type==NOCARDUSER){
return getNoCardPrice(price);
}else if(type ==IRONCARDUSER){
return getIronCardPrice(price);
}else if(type ==GOLDCARDUSER){
return getGoldCardPrice(price);
}else {
return 0;
}
}
}
执行实例：
呀，得出正确的答案了，这时你是不是应该满足了呢。应该高枕无忧了呢？突然，主管说要添加钻石用户的类别，钻石用户打六折，这时你怎么实现呢？在里面在添加钻石用户的类型，再添加计算钻石用户的方法，再再最后的推断里添加i f else？ 这种确能够实现功能，可是是不是不满足开闭原则呢？并且随着用户种类的不断添加，你的if else是不是也越来越长，逻辑也越来越复杂呢？导致系统扩展性和稳定性越来越差呢？ 所以，这种方式在实际中显然实不可取的，以下我们看一下怎样使用策略模式来实现上面的需求。
1.PriceStrategyInterface 接口，相应UML类图中的Strategy接口：
package com.strategy.demo;
public interface PriceStrategyInterface {
double calPrice(double price);
}
2.实现类，无卡用户：
package com.strategy.demo;
public class NoCardUserStrategy implements PriceStrategyInterface {
/**
* 无牌买家。原价
*/
@Override
public double calPrice(double price) {
return price;
}
}
3.实现类。铁卡用户：
package com.strategy.demo;
public class IronCardUserStrategy implements PriceStrategyInterface {
/*
* 铁牌买家
* (non-Javadoc)
* @see com.strategy.demo.PriceStrategyInterface#calPrice(double)
*/
@Override
public double calPrice(double price) {
return price*0.9;
}
}
4.实现类。金卡用户：
package com.strategy.demo;
public class GoldCardUserStrategy implements PriceStrategyInterface {
/**
* 金牌买家
*/
@Override
public double calPrice(double price) {
return price*0.7;
}
}
5.环境对象。用来操作策略：
package com.strategy.demo;
public class PriceContext {
/**
* 操作类
*/
PriceStrategyInterface priceStrategyInterface;
/*
* 通过初始化传入对象
*/
public PriceContext(PriceStrategyInterface priceStrategyInterface) {
this.priceStrategyInterface=priceStrategyInterface;
}
/*
* 通过对象计算返回值
*/
public double getPrice(double price){
return priceStrategyInterface.calPrice(price);
}
}
环境对象初始化时。将相应的策略对象传入，然后调用方法返回计算值。
6.构建測试类，測试：
package com.strategy.demo;
public class TestClass {
public static void main(String[] args) {
PriceContext priceContext=new PriceContext(new NoCardUserStrategy());
System.out.println("没有卡牌的买家买100元货物终于应付款："+priceContext.getPrice(100.0));
PriceContext priceContext2=new PriceContext(new IronCardUserStrategy());
System.out.println("铁牌的买家买100元货物终于应付款："+priceContext2.getPrice(100.0));
PriceContext priceContext3=new PriceContext(new GoldCardUserStrategy());
System.out.println("金牌的买家买100元货物终于应付款："+priceContext3.getPrice(100.0));
}
}
执行上面的实例：
得到了和第一个方法一样的正确答案，这时我们假如要添加一个钻石买家的种类。怎么实现呢？我们仅仅须要添加一个策略实现类：
package com.strategy.demo;
public class DiamondUserStrategy implements PriceStrategyInterface {
@Override
public double calPrice(double price) {
return price*0.6;
}
}
然后測试类添加一条钻石类买家的购物：
package com.strategy.demo;
public class TestClass {
public static void main(String[] args) {
PriceContext priceContext=new PriceContext(new NoCardUserStrategy());
System.out.println("没有卡牌的买家买100元货物终于应付款："+priceContext.getPrice(100.0));
PriceContext priceContext2=new PriceContext(new IronCardUserStrategy());
System.out.println("铁牌的买家买100元货物终于应付款："+priceContext2.getPrice(100.0));
PriceContext priceContext3=new PriceContext(new GoldCardUserStrategy());
System.out.println("金牌的买家买100元货物终于应付款："+priceContext3.getPrice(100.0));
PriceContext priceContext4=new PriceContext(new DiamondUserStrategy());
System.out.println("钻石卡的买家买100元货物终于应付款："+priceContext4.getPrice(100.0));
}
}
执行实例：
是不是扩展起来特别easy？条理也十分清晰。总结一下策略模式的长处：
1. 结构清晰，使用简单直观。
2. 系统耦合性减少。扩展方便；
3. 操作封装彻底。数据更为安全。（在TestClass中，仅仅知道相关实现类，并不涉及详细计算方法）
当然，策略方式也存在一定的缺点：
由图能够直观的看出，随着策略的不断添加。子类数量变得庞大。
喜欢的朋友关注我和我的微信平台