告别if/else连环写法

1、once Upon a time

在平时的编码过程中，我们大部分新手可能都特别钟情于 if/else连环写法，比如举个简单栗子：

拿订单来说，我们正常的订单类型有多种，那么对应就会生成不同的收款，调用生成收款单的接口也就不一样，比如：

• 寄售订单（CONSIGNMENT）：调用A方法生成收款单
• 销售订单（SALE）：调用B方法生成收款单
• 拍卖订单（AUCTION）：调用C方法生成收款单

比如一个订单进来，我们需要根据不同的订单类型来判断其调用哪个生成收款单的接口，if/else连环写法出现了：

 public String AddReceipt(String saleType) {
        String result = "";
        if (saleType.equals("CONSIGNMENT")) {
            result = "寄售订单: " + "调用A方法生成收款单";
        } else if (saleType.equals("SALE")) {
            result = "销售订单: " + "调用B方法生成收款单";
        } else if (saleType.equals("AUCTION")) {
            result = "拍卖订单: " + "调用C方法生成收款单";
        } else {
            result = "XXX";
        }
        return result;
    }

这样当订单类型有十几个时：

• 一来那十几个 if/else嵌套可以说是非常不优雅，别人阅读起来很费劲；
• 二来则是以后如果再复杂一点，或者想要再加条件的话不好扩展；
• 而且代码一改，以前的老功能有时还得重测

所以，我们就得尝试去寻找其他方法来应对这种情况，你一般会如何去对付这些令人头痛的if/else语句呢？

当然有人会说用 switch/case来写是否会优雅一些呢？答案是if/else没什么区别！

接下来简单讲几种改进方式，告别 if/else走天下

2、使用枚举

什么订单类型能干什么事，这很明显有一个对应关系，所以有枚举为啥不用呢？

首先定义一个公用接口 AddReceiptOperation，表示不同订单所能做的操作：

  public interface AddReceiptOperation {
        String addReceipt(); // 表示某个订单可以addReceipt操作
    }

接下来我们将不同订单类型的情况全部交由枚举类来做，定义一个不同订单类型有不同权限的枚举类OrderTypeEnum

   public enum OrderTypeEnum implements AddReceiptOperation {

        // 寄售订单
        CONSIGNMENT {
            @Override
            public String addReceipt() {
                return "寄售订单:" + " 调用A方法生成收款单";
            }
        },

        // 销售订单
        SALE {
            @Override
            public String addReceipt() {
                return "销售订单:" + " 调用B方法生成收款单";
            }
        },

        // 拍卖订单
        AUCTION {
            @Override
            public String addReceipt() {
                return "拍卖订单:" + " 调用C方法生成收款单";
            }
        };
    }

接下来调用就变得简单了，一行代码就行了， if/else也不存在了：

   public class AddReceipt {
        public String judge(String saleType) {
            // 一行代码搞定！之前的if/else没了！
            return OrderTypeEnum.valueOf(saleType).addReceipt();
        }
    }

而且这样一来，以后假如我想扩充条件，只需要去枚举类中加代码即可，而不是去改以前的代码。

3、使用工厂模式

除了用枚举来消除 if/else，工厂模式也可以实现

不同类型的订单做不同的事情，很明显就提供了使用工厂模式的契机，我们只需要将不同情况单独定义好，然后去工厂类里面聚合即可。

首先，针对不同的订单类型，单独定义其业务类

// 寄售订单业务类
public class ConsignmentOrder implements AddReceiptOperation {
    private String orderType;

    public ConsignmentOrder(String orderType) {
        this.orderType = orderType;
    }

    @Override
    public String addReceipt() {
        return orderType + " 调用A方法生成收款单";
    }
}
// 销售订单业务类
public class SaleOrder implements AddReceiptOperation {
    private String orderType;

    public SaleOrder(String orderType) {
        this.orderType = orderType;
    }

    @Override
    public String addReceipt() {
        return orderType + " 调用B方法生成收款单";
    }
}
// 拍卖订单业务类
public class AuctionOrder implements AddReceiptOperation {
    private String orderType;

    public AuctionOrder(String orderType) {
        this.orderType = orderType;
    }

    @Override
    public String addReceipt() {
        return orderType + " 调用C方法生成收款单";
    }
}

接下来再写一个工厂类 OrderTypeFactory对上面不同订单类型进行聚合：

   public class OrderTypeFactory {
    static Map<String, AddReceiptOperation> addReceiptOpaerationMap = new HashMap<>();

    // 在静态块中先把初始化工作全部做完
    static {
        addReceiptOpaerationMap.put("CONSIGNMENT", new ConsignmentOrder("寄售订单"));
        addReceiptOpaerationMap.put("SALE", new SaleOrder("销售订单"));
        addReceiptOpaerationMap.put("AUCTION", new AuctionOrder("拍卖订单"));
    }

    public static AddReceiptOperation getOp(String oederType) {
        return addReceiptOpaerationMap.get(oederType);
    }

}

接下来借助上面这个工厂，业务代码调用也只需一行代码， if/else同样被消除了：

    public class AddReceipt {
        public String judge(String saleType) {
            // 一行代码搞定！之前的if/else没了！
            return OrderTypeFactory.getOp(saleType).addReceipt()
        }
    }

这样的话以后想扩展条件也很容易，只需要增加新代码，而不需要动以前的业务代码，非常符合“开闭原则”。

4、除了工厂模式，策略模式也不妨试一试

策略模式和工厂模式写起来其实区别也不大！

在上面工厂模式代码的基础上，按照策略模式的指导思想，我们也来创建一个所谓的策略上下文类，这里命名为 OrderTypeContext：

public class OrderTypeContext {
    // 可更换的策略，传入不同的策略对象，业务即相应变化
    private AddReceiptOperation operation;
    public OrderTypeContext(AddReceiptOperation operation) {
        this.operation = operation;
    }
    public String execute() {
        return operation.addReceipt();
    }
}

很明显上面传入的参数 operation就是表示不同的“策略”。我们在业务代码里传入不同的订单类型，即可得到不同的操作结果：

　　public class JudgeOrderType {
    public String judge(AddReceiptOperation addReceiptOperation) {
        OrderTypeContext orderTypeContext = new OrderTypeContext(addReceiptOperation);
        return orderTypeContext.execute();
    }

    public static void main(String[] args) {
        JudgeOrderType judgeOrderType = new JudgeOrderType();
        String result1 = judgeOrderType.judge(new ConsignmentOrder("CONSIGNMENT"));
        System.out.println( result1 );
        String result2 = judgeOrderType.judge(new SaleOrder("SALE"));
        System.out.println( result2 );
        String result3 = judgeOrderType.judge(new AuctionOrder("AUCTION"));
        System.out.println( result3 );

    }
}

本文仅仅使用了一个极其简单的示例来打了个样，然而其思想可以广泛地应用于实际复杂的业务和场景，思想真的很重要，写代码前可以多思考一番，考虑是否有更具可扩展性的写法。