尽量避免臃肿的if else

使用if...else...的弊端在于：不利于对程序的扩展，如果新添加了一个类型，那么就得去修改程序再添加一个if...else...分支，根据“开-闭原则”的宗旨：对扩展开，对修改闭。显然是用if...else...已经go out了。
面向过程设计和面向对象设计的主要区别是：是否在业务逻辑层使用冗长的if else判断。
将if else用在小地方还可以，如简单的数值判断；但是如果按照你的传统习惯思维，在实现业务功能时也使用if else，那么说明你的思维可能思维停留在传统的面向过程语言上,需要重塑。

那么实战中，哪些设计模式可以替代if else呢？
状态模式,策略模式,代理或动态代理模式,AOP或Decorator模式,
其实使用filter过滤器也可以替代我们业务中的if else，过滤器起到一种过滤和筛选作用，将符合本过滤器条件的对象拦截下来做某件事情，这就是一个过滤器的功能，多个过滤器组合在一起实际就是if else的组合。

1、如果程序中只有一个else,如下：
            if(con){
                  dosomething();
            }else{
                  dootherthings();
            }
        可以如下拒绝else：
            if(con){
                  dosomething();
                  return;
            }
            dootherthings();
         或者使用三元运算符：con ? dosometing() : dootherthings();
 
        2、如果程序中有多个else,如下：
            if(con1){
                  dothing1();
            }else if(con2){
                  dothing2();
            }else if(con3){
                  dothing3();
            }......

在实际的spring项目中，通常使用spring的List,Set,Map,配置文件注入来避免过度使用if else.
如我们在分布式项目中通常定义一个facade接口，负责接收其他系统的请求，
通常不同的业务逻辑则根据请求中的类型参数来区分，如交易类型为转入01或转出02。

1.接口定义如下：
@WebService
public interface PayFacade {  
/**
*  转入01或转出02
*/
public Response Pay(@WebParam(name="transType")String transType);
}


2.接口实现如下：
我们可以在接口中定义map，list,set等，由spring配置文件注入。
public class PayFacadeImpl implements PayFacade{
    private Map<String,AbstractHandler> mapping=null;
    private Set<String> sets;
    
    public Response Pay(String transType) {
        AbstractHandler  handler= mapping.get(transType);        
    return handler.execute();//根据类型不同跳转到不同的接口实现来处理不同的业务逻辑
    }
}


3.spring配置如下：
<bean id="PayBean" class="com.xxx.PayFacadeImpl" >
<property name="mapping">
<map  key-type="java.lang.String" value-type="com.xxx.AbstractHandler">
<entry key="01">
<bean class="com.xxx.Handler1"></bean>
</entry>
<entry key="02">
<bean class="com.xxx.Handler2"></bean>
</entry>
</map>
</property>
</bean>


或者
<property name="sets">
<set>
<value>01</value>
<value>02</value>
</set>
</property>

对于以上一个接口多种实现方式就是我们所说的策略模式，下面介绍“策略模式”的方式：以下摘抄网上的例子。 

需求如下：

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

①网银充值，8.5折；

②商户充值，9折；

③手机充值，没有优惠；

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

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

Java代码  

package strategy;

 

public class Example {

    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代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public interface Strategy {

    public Double calRecharge(Double charge ,RechargeTypeEnum type );

}

 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

 public class EBankStrategy implements Strategy{

    @Override

    public Double calRecharge(Double charge, RechargeTypeEnum type) {

       return charge*0.85;

    }

} 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public class BusiAcctStrategy implements Strategy{

    @Override

    public Double calRecharge(Double charge, RechargeTypeEnum type) {

       // TODO Auto-generated method stub

       return charge*0.90;

    }

} 

 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public class MobileStrategy implements Strategy {

    @Override

    public Double calRecharge(Double charge, RechargeTypeEnum type) {

       // TODO Auto-generated method stub

       return charge;

    }

}

 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public class CardStrategy implements Strategy{

    @Override

    public Double calRecharge(Double charge, RechargeTypeEnum type) {

       return charge+charge*0.01;

    }

} 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public class Context {

    private Strategy strategy; 

    public Double calRecharge(Double charge, Integer type) {

       strategy = StrategyFactory.getInstance().creator(type);

       return strategy.calRecharge(charge, RechargeTypeEnum.valueOf(type));

    }

    public Strategy getStrategy() {

       return strategy;

    }

    public void setStrategy(Strategy strategy) {

       this.strategy = strategy;

    }

} 

Java代码  

package strategy.strategy;

import java.util.HashMap;

import java.util.Map;

import strategy.RechargeTypeEnum;

public class StrategyFactory { 

    private static StrategyFactory factory = new StrategyFactory();

    private StrategyFactory(){

    }

    private static Map strategyMap = new HashMap<>();

    static{

       strategyMap.put(RechargeTypeEnum.E_BANK.value(), new EBankStrategy());

       strategyMap.put(RechargeTypeEnum.BUSI_ACCOUNTS.value(), new BusiAcctStrategy());

       strategyMap.put(RechargeTypeEnum.MOBILE.value(), new MobileStrategy());

       strategyMap.put(RechargeTypeEnum.CARD_RECHARGE.value(), new CardStrategy());

    }

    public Strategy creator(Integer type){

       return strategyMap.get(type);

    }

    public static StrategyFactory getInstance(){

       return factory;

    }

} 

Java代码  

package strategy.strategy;

import strategy.RechargeTypeEnum;

public class Client {

    public static void main(String[] args) {

       Context context = new Context();

       // 网银充值100 需要付多少

       Double money = context.calRecharge(100D,

              RechargeTypeEnum.E_BANK.value());

       System.out.println(money);

 

       // 商户账户充值100 需要付多少

       Double money2 = context.calRecharge(100D,

              RechargeTypeEnum.BUSI_ACCOUNTS.value());

       System.out.println(money2);

 

       // 手机充值100 需要付多少

       Double money3 = context.calRecharge(100D,

              RechargeTypeEnum.MOBILE.value());

       System.out.println(money3);

 

       // 充值卡充值100 需要付多少

       Double money4 = context.calRecharge(100D,

              RechargeTypeEnum.CARD_RECHARGE.value());

       System.out.println(money4);

    }

}