如何优雅地优化代码中的的if else和switch

引言

通常来讲，随着咱们项目的迭代以及业务的愈来愈复杂，项目中的分支判断会原来越多。当项目中涉及到复杂的业务判断或者分支逻辑时，咱们就须要考虑是否须要对项目进行重构了，或者if else和switch case是否可以知足当前项目的复杂度。

咱们举一个简单的例子，假如咱们是马戏团的老板，在训练一些动物去作一些指令，刚开始很简单，只训练了一条狗，当狗握了一下手后，给她奖励一些狗粮。这样慢慢地小狗就学会了握手。

咱们先定义一条小狗对象，小狗作了某些事情(“握手”)后，能够获得一些奖励

public class Dog {
    public void train(){
        System.out.println("握手");
    }
    public void getReward(){
        System.out.println("狗粮");
    }
}

定义驯兽师，经过train来训练动物

public class Beast {
    /**
     * 训练
     */
    public void train(Dog dog){
        /**
         * 狗狗作了一些事情
         */
        dog.train();
        /**
         * 狗狗获得奖励
         */
        dog.getReward();
    }
}

若是咱们只须要训练一条动物，那么相对来讲比较简单。可是后来马戏团又引进了一头狮子，须要训练狮子钻火圈，所以，为了区分狗和狮子，咱们增长了一种类型区分训练的动物是狗仍是狮子。

public class Lion {
    public void train(){
        System.out.println("钻火圈");
    }
    public void getReward(){
        System.out.println("获得一只鸡");
    }
}

从新修改Beast类，使其既能够训练小狗，又能够训练狮子

public class Beast {
    
    public void train(Object animal, int type){
        if (type == 1){
            trainDog((Dog)animal);
        }else if (type == 2){
            trainLion((Lion)animal);
        }
    }
    
    /**
     * 训练
     */
    public void trainDog(Dog dog){
        /**
         * 狗狗作了一些事情
         */
        dog.train();
        /**
         * 狗狗获得奖励
         */
        dog.getReward();
    }
    /**
     * 训练
     */
    public void trainLion(Lion lion){
        /**
         * 狗狗作了一些事情
         */
        lion.train();
        /**
         * 狗狗获得奖励
         */
        lion.getReward();
    }
}

咱们经过type类型来区分训练的动物类型，后来马戏团引来了愈来愈多的动物，那咱们的type的取值会愈来愈多：1表示狗，2表示狮子，3表示猫，4表示老虎，5表示猴子...等等。并且随着系统愈来愈复杂，咱们在训练以前不一样的动物还须要作不一样的准备工做。固然，目前的系统只要增长if else或者switch case是能够知足需求的，但这样写显得不是太优雅，咱们但愿找到一种比较优雅比较有设计感的方式来取代if else或者switch case

优化if else

在作优化以前，咱们须要先弄清楚咱们的目的。咱们是马戏团的驯兽师，目的是训练动物。

• 目的：训练动物作一些事情(doSomething)
• 方式：经过奖励(getReward)诱导动物进行训练。

有了上面的目的以后，咱们就能够定义一个模型animal

public interface IAnimal {

    /**
     * 获取动物种类
     * @return
     */
    int getType();
    
    /**
     * 训练动做
     */
    void train();
}

Animal只暴露两个方法，其中doSomething是专门用来训练动物的，至于如何训练全都由子类实现。

• getType():用来区分不一样的动物
• train():训练动物

而后咱们定义一个子类实现这个接口，用来具体化如何训练动物

public abstract class AbsTrainAnimal implements IAnimal{

    /**
     * 训练前须要作的准备
     */
    abstract void beforeTrain();

    /**
     * 训练后须要作的准备
     */
    abstract void afterTrain();

    /**
     * 训练出现异常须要作的
     */
    abstract void exceptionTrain(Throwable throwable);

    /**
     * 具体训练
     */
    abstract void doSomething();
    
    /**
     * 训练动做
     */
    @Override
    public final void train() {
        try {
            beforeTrain();
            doSomething();
            afterTrain();
        }catch (Throwable throwable){
            exceptionTrain(throwable);
        }
    }
}

咱们定义了一个抽象类用来实现IAnimal接口，做为全部动物训练的基类。其中实现的接口train使用了final进行了限制，防止子类对其进行覆盖操做。

在AbsTrainAnimal中，咱们对train()进行了各类功能的细化

• doSomething：具体训练的内容
• beforeTrain：训练以前须要作的一些准备
• afterTrain：训练以后须要作的事情
• exceptionTrain：训练中发生意外应该如何处理

由于全部动物的以上四个方法可能都不相同，因此咱们声明为abstract方法，方便子类本身实现。基于以上设计，咱们就能够定义一个Dog类，对其进行训练。

public class Dog extends AbsTrainAnimal {
    /**
     * 训练前须要作的准备
     */
    @Override
    void beforeTrain() {
        System.out.println("抚摸额头以示鼓励");
    }

    /**
     * 训练后须要作的准备
     */
    @Override
    void afterTrain() {
        System.out.println("奖励一些狗粮");
    }

    /**
     * 训练出现异常须要作的
     *
     * @param throwable
     */
    @Override
    void exceptionTrain(Throwable throwable) {
        System.out.println("出去罚站");
    }

    /**
     * 具体训练
     */
    @Override
    void doSomething() {
        System.out.println("握手");
    }

    /**
     * 获取动物种类
     *
     * @return
     */
    @Override
    public int getType() {
        return 1;
    }
}

同时定义一个狮子Lion

public class Lion extends AbsTrainAnimal {
    /**
     * 训练前须要作的准备
     */
    @Override
    void beforeTrain() {
        System.out.println("友好交流");
    }

    /**
     * 训练后须要作的准备
     */
    @Override
    void afterTrain() {
        System.out.println("奖励一只鸡");
    }

    /**
     * 训练出现异常须要作的
     *
     * @param throwable
     */
    @Override
    void exceptionTrain(Throwable throwable) {
        System.out.println("紧急送往医院");
    }

    /**
     * 具体训练
     */
    @Override
    void doSomething() {
        System.out.println("钻火圈");
    }

    /**
     * 获取动物种类
     *
     * @return
     */
    @Override
    public int getType() {
        return 2;
    }
}

咱们能够看到，Dog和Lion的动物种类是不同的，Dog为1，Lion为2。咱们能够根据type区分是狮子仍是狗。但为了不使用if else进行区分，咱们须要一个工厂类来生产这两种动物。

@Service
public class AnimalFactory {
    
    private static List<Class<? extends IAnimal>> animalLists = Lists.newArrayList();
    private static Map<Integer, IAnimal> animalMaps = Maps.newHashMap();
    
    static {
        animalLists.add(Dog.class);
        animalLists.add(Lion.class);
    }
    
    @PostConstruct
    public void init() throws IllegalAccessException, InstantiationException {
        for (Class<? extends IAnimal> clazz : animalLists){
            Object obj = clazz.newInstance();
            animalMaps.put(obj.getType(), obj);
        }
    }

    /**
     * 构建动物类
     * @param type
     * @return
     */
    IAnimal build(int type){
        return animalMaps.get(type);
    }
}

咱们有了这个工厂类，就能够根据不一样的动物类型获取不一样的对象，并对其进行训练。固然咱们这里都是使用的单例模式，每一个对象只对应一个实例，若是每次都生成不一样的实例，能够对其进行简单的改造便可实现。

咱们再重写驯兽师Beast类

@Service
public class Beast {

    @Resource
    private AnimalFactory animalFactory;

    /**
     * 训练动物，只须要知道动物的类型便可
     * @param type
     */
    public void train(int type){
        IAnimal animal = animalFactory.build(type);
        animal.train();
    }
}

能够看到train方法只须要关系动物类型便可，不须要再根据type进行判断动物类型在对其进行不一样的操做。若是有新的动物加入，只须要实现AbsTrainAnimal基类，而后向AnimalFactory进行注册便可。避免了根据不一样type进行if else或者switch的判断

总结

其实，上述所述的方法不但但省去了if else的判断，也是目前比较流行的领域模型的一种实现方式。IAnimal是领域内对外暴露的惟一方式，外部领域(驯兽师)不须要关心任何内部实现的细节。内部的实现彻底集合在IAnimal内。