zoukankan      html  css  js  c++  java

  • 【转】Java策略消除if else

    策略（Strategy）模式：又名Policy，它的用意是定义一组算法，把它们一个个封装起来，并且使他们可以相互替换。策略模式可以独立于使用他们的客户端而变化。GOF策略模式静态结构类图如下：

    通过上图可以看出策略模式有以下角色构成：

    1、抽象策略（Strategy）角色：抽象策略角色由抽象类或接口来承担，它给出具体策略角色需要实现的接口；

    2、具体策略（ConcreteStrategy）角色：实现封装了具体的算法或行为；

    3、场景（Context）角色：持有抽象策略类的引用。

    策略模式重点是封装不同的算法和行为，不同的场景下可以相互替换。策略模式是开闭原则的体现，开闭原则讲的是一个软件实体应该对扩展开放对修改关闭。策略模式在新的策略增加时，不会影响其他类的修改，增加了扩展性，也就是对扩展是开放的；对于场景来说，只依赖于抽象，而不依赖于具体实现，所以对修改是关闭的。策略模式的认识可以借助《java与模式》一书中写到诸葛亮的锦囊妙计来学习，在不同的场景下赵云打开不同的锦囊，便化险为夷，锦囊便是抽象策略，具体的锦囊里面的计策便是具体的策略角色，场景就是赵云，变化的处境

    选择具体策略的条件。

    策略模式在程序设计中也很常用，在板桥（banq）的博客里有篇文章叫 “你还在用if else吗？”
    “http://www.jdon.com/artichect/ifelse.htm”讲的很好，策略模式不但是继承的代替方案而且能很好地解决if else问题，下面举个实例来说明，怎么使用策略模式。

    需求如下：

    某支付系统接入以下几种商户进行充值：易宝网易，快线网银，19pay手机支付，支付宝支付，骏网一卡通，由于每家充值系统的结算比例不一样，而且同一家商户的不同充值方式也有所不同，具体系统情况比较复杂，像支付宝既有支付宝账号支付和支付宝网银支付等这些暂时不考虑，为了讲述策略模式这里简单描述，假如分为四种，手机支付，网银支付，商户账号支付和点卡支付。因为没个支付结算比例不同，所以对手续费低的做一些优惠活动，尽可能让用户使用手续费低的支付方式来充值，这样降低渠道费用，增加收入，具体优惠政策如下：

    ①网银充值，8.5折；

    ②商户充值，9折；

    ③手机充值，没有优惠；

    ④点卡充值，收取1%的渠道费；

    对于一个新手的代码如下：

    Java代码  收藏代码
        package strategy;  
      
    public class Example {  
      
        /** 
         *  
         *作者：alaric 
         *时间：2013-8-5上午11:00:06 
         *描述：计算用户所付金额 
         */  
        public Double calRecharge(Double charge ,RechargeTypeEnum type ){  
              
            if(type.equals(RechargeTypeEnum.E_BANK)){  
                return charge*0.85;  
            }else if(type.equals(RechargeTypeEnum.BUSI_ACCOUNTS)){  
                return charge*0.90;  
            }else if(type.equals(RechargeTypeEnum.MOBILE)){  
                return charge;  
            }else if(type.equals(RechargeTypeEnum.CARD_RECHARGE)){  
                return charge+charge*0.01;  
            }else{  
                return null;  
            }  
      
        }  
          
    }
    Java代码  收藏代码
        package strategy;  
      
    public enum RechargeTypeEnum {  
      
        E_BANK(1, "网银"),  
          
        BUSI_ACCOUNTS(2, "商户账号"),  
          
        MOBILE(3,"手机卡充值"),  
          
        CARD_RECHARGE(4,"充值卡")  
        ;  
          
        /** 
         * 状态值 
         */  
        private int value;  
          
        /** 
         * 类型描述 
         */  
        private String description;  
          
          
          
        private RechargeTypeEnum(int value, String description) {  
            this.value = value;  
            this.description = description;  
        }  
              
        public int value() {  
            return value;  
        }  
        public String description() {  
            return description;  
        }  
          
      
        public static RechargeTypeEnum valueOf(int value) {  
            for(RechargeTypeEnum type : RechargeTypeEnum.values()) {  
                if(type.value() == value) {  
                    return type;  
                }  
            }  
            return null;   
        }  
    }

     可以看出上面四种不同的计算方式在一个方法内部，不利于扩展和维护，当然也不符合面向对象设计原则。对以上的代码利用策略模式进行修改，类图如下：


     实例代码如下：

    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4.   
    5. /** 
    6.  *  
    7.  *作者：alaric 
    8.  *时间：2013-8-5上午11:03:17 
    9.  *描述：策略抽象类 
    10.  */  
    11. public interface Strategy {  
    12.   
    13.     /** 
    14.      *  
    15.      *作者：alaric 
    16.      *时间：2013-8-5上午11:05:11 
    17.      *描述：策略行为方法 
    18.      */  
    19.     public Double calRecharge(Double charge ,RechargeTypeEnum type );  
    20. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4. /** 
    5.  *  
    6.  *作者：alaric 
    7.  *时间：2013-8-5上午11:14:23 
    8.  *描述：网银充值 
    9.  */  
    10. public class EBankStrategy implements Strategy{  
    11.   
    12.     @Override  
    13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
    14.         return charge*0.85;  
    15.     }  
    16.   
    17.       
    18.   
    19. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4. /** 
    5.  *  
    6.  *作者：alaric 
    7.  *时间：2013-8-5上午11:14:08 
    8.  *描述：商户账号充值 
    9.  */  
    10. public class BusiAcctStrategy implements Strategy{  
    11.   
    12.     @Override  
    13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
    14.         // TODO Auto-generated method stub  
    15.         return charge*0.90;  
    16.     }  
    17.   
    18. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4. /** 
    5.  *  
    6.  *作者：alaric 
    7.  *时间：2013-8-5上午11:14:43 
    8.  *描述：手机充值 
    9.  */  
    10. public class MobileStrategy implements Strategy {  
    11.   
    12.     @Override  
    13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
    14.         // TODO Auto-generated method stub  
    15.         return charge;  
    16.     }  
    17.   
    18. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4. /** 
    5.  *  
    6.  *作者：alaric 
    7.  *时间：2013-8-5上午11:13:46 
    8.  *描述：充值卡充值 
    9.  */  
    10. public class CardStrategy implements Strategy{  
    11.   
    12.     @Override  
    13.     public Double calRecharge(Double charge, RechargeTypeEnum type) {  
    14.         return charge+charge*0.01;  
    15.     }  
    16.   
    17. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4.   
    5. /** 
    6.  *  
    7.  *作者：alaric 
    8.  *时间：2013-8-5上午11:03:38 
    9.  *描述：场景类 
    10.  */  
    11. public class Context {  
    12.   
    13.     private Strategy strategy;  
    14.       
    15.     public Double calRecharge(Double charge, Integer type) {  
    16.         strategy = StrategyFactory.getInstance().creator(type);  
    17.         return strategy.calRecharge(charge, RechargeTypeEnum.valueOf(type));  
    18.     }  
    19.   
    20.     public Strategy getStrategy() {  
    21.         return strategy;  
    22.     }  
    23.   
    24.     public void setStrategy(Strategy strategy) {  
    25.         this.strategy = strategy;  
    26.     }  
    27.       
    28. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import java.util.HashMap;  
    4. import java.util.Map;  
    5.   
    6. import strategy.RechargeTypeEnum;  
    7. /** 
    8.  *  
    9.  *作者：alaric 
    10.  *时间：2013-8-5上午11:31:12 
    11.  *描述：策略工厂 使用单例模式 
    12.  */  
    13. public class StrategyFactory {  
    14.   
    15.     private static StrategyFactory factory = new StrategyFactory();  
    16.     private StrategyFactory(){  
    17.     }  
    18.     private static Map<Integer ,Strategy> strategyMap = new HashMap<>();  
    19.     static{  
    20.         strategyMap.put(RechargeTypeEnum.E_BANK.value(), new EBankStrategy());  
    21.         strategyMap.put(RechargeTypeEnum.BUSI_ACCOUNTS.value(), new BusiAcctStrategy());  
    22.         strategyMap.put(RechargeTypeEnum.MOBILE.value(), new MobileStrategy());  
    23.         strategyMap.put(RechargeTypeEnum.CARD_RECHARGE.value(), new CardStrategy());  
    24.     }  
    25.     public Strategy creator(Integer type){  
    26.         return strategyMap.get(type);  
    27.     }  
    28.     public static StrategyFactory getInstance(){  
    29.         return factory;  
    30.     }  
    31. }  
    Java代码  收藏代码
    1. package strategy.strategy;  
    2.   
    3. import strategy.RechargeTypeEnum;  
    4.   
    5. public class Client {  
    6.   
    7.     /** 
    8.      * 作者：alaric 时间：2013-8-5上午11:33:52 描述： 
    9.      */  
    10.     public static void main(String[] args) {  
    11.   
    12.         Context context = new Context();  
    13.         // 网银充值100 需要付多少  
    14.         Double money = context.calRecharge(100D,  
    15.                 RechargeTypeEnum.E_BANK.value());  
    16.         System.out.println(money);  
    17.   
    18.         // 商户账户充值100 需要付多少  
    19.         Double money2 = context.calRecharge(100D,  
    20.                 RechargeTypeEnum.BUSI_ACCOUNTS.value());  
    21.         System.out.println(money2);  
    22.   
    23.         // 手机充值100 需要付多少  
    24.         Double money3 = context.calRecharge(100D,  
    25.                 RechargeTypeEnum.MOBILE.value());  
    26.         System.out.println(money3);  
    27.   
    28.         // 充值卡充值100 需要付多少  
    29.         Double money4 = context.calRecharge(100D,  
    30.                 RechargeTypeEnum.CARD_RECHARGE.value());  
    31.         System.out.println(money4);  
    32.     }  
    33.   
    34. }  

    运行结果：

    85.0

    90.0

    100.0

    101.0

    从上面类图和代码可以看出，策略模式把具体的算法封装到了具体策略角色内部，增强了可扩展性，隐蔽了实现细节；它替代继承来实现，避免了if-else这种不易维护的条件语句。当然我们也可以看到，策略模式由于独立策略实现，使得系统内增加了很多策略类；对客户端来说必须知道兜友哪些具体策略，而且需要知道选择具体策略的条件。
     
    原文：http://alaric.iteye.com/blog/1920714
  • 相关阅读:
    《程序员成长的烦恼》
    我们一起读《暗时间》
    CSS选择器分类总结
    CSharp如何自定义鼠标样式
    Android开发消除横向排列的多个Button之间的空隙
    JS代码指导原则
    Android蓝牙联机Demo解析
    排序算法之堆排序（Heapsort）解析
    排序算法之归并排序（Mergesort）解析
    经典串匹配算法（KMP）解析
  • 原文地址：https://www.cnblogs.com/zdd-java/p/6143935.html
Copyright © 2011-2022 走看看