if else语句的优化

前言

日常开发中，我们会经常遇到根据传入的值，来判断程序该走哪段代码，走哪个方法，通常我们会使用if else语句来进行判断。如果传入的值有很多中情况，我们也就会写很多的if else来判断，这样代码就会显得非常臃肿，难以维护。后期新加的条件不太容易扩展，测试时也要重新把整个if else语句再测试一遍，非常费时间又不方便。接下来给大家介绍几种方法，不使用if else语句也能做条件判断。

使用枚举

首先定义一个公用接口 RoleOperation，表示不同角色所能做的操作

package com.gavin.enums;

public interface RoleOperation {

    //定义一个方法来表示某个角色，有哪些op（操作）权限
    String op();
}

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

package com.gavin.enums;

public enum RoleEnum implements RoleOperation{

    //定义一个超级管理员的操作权限（有AAA的操作权限）
    ROLE_ROOT_ADMIN {
        @Override
        public String op() {
            return "ROLE_ROOT_ADMIN:has AAA permission";
        }
    },

    //定义一个订单管理员的操作权限（有BBB的操作权限）
    ROLE_ORDER_ADMIN {
        @Override
        public String op() {
            return "ROLE_ORDER_ADMIN:has BBB permission";
        }
    },

    //定义一个普通用户的操作权限（有CCC的操作权限）
    ROLE_NORMAL {
        @Override
        public String op() {
            return "ROLE_NORMAL:has CCC permission";
        }
    };
}

接下来调用就变得异常简单了，一行代码就行了， if/else也灰飞烟灭了：

package com.gavin.enums;

public class JudgeRole {

    public static void main(String[] args) {
        String roleName = "ROLE_ROOT_ADMIN";
        String operation = RoleEnum.valueOf(roleName).op();
        System.out.println("操作权限：" + operation);
    }
}

而且这样一来，以后我想扩充条件，只需要去枚举类中加代码即可

使用工厂模式

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

首先，针对不同的角色，单独定义其业务类：

package com.gavin.factory;

import com.gavin.enums.RoleOperation;

public class RootAdminRole implements RoleOperation {

    //定义属性值
    private String roleName;

    //有参构造方法
    public RootAdminRole (String roleName) {
        this.roleName = roleName;
    }

    //实现RoleOperation接口，然后重写接口方法
    @Override
    public String op() {
        return roleName + " has AAA permission";
    }
}

package com.gavin.factory;

import com.gavin.enums.RoleOperation;

public class OrderAdminRole implements RoleOperation {

    //定义属性值
    private String roleName;

    //有参构造方法
    public OrderAdminRole(String roleName) {
        this.roleName = roleName;
    }

    //实现RoleOperation接口，然后重写接口方法
    @Override
    public String op() {
        return roleName + " has BBB permission";
    }
}

package com.gavin.factory;

import com.gavin.enums.RoleOperation;

public class NormalRole implements RoleOperation {

    //定义属性值
    private String roleName;

    //有参构造方法
    public NormalRole(String roleName) {
        this.roleName = roleName;
    }

    //实现RoleOperation接口，然后重写接口方法
    @Override
    public String op() {
        return roleName + " has CCC permission";
    }
}

接下来再写一个工厂类 RoleFactory对上面不同角色进行聚合：

package com.gavin.factory;

import com.gavin.enums.RoleOperation;

import java.util.HashMap;
import java.util.Map;

public class RoleFactory {

    //定义一个Map集合，使用static修饰后会与类一起加载进堆中
    //加载顺序早于没有用static修饰的常量、变量和方法
    static Map<String, RoleOperation> map = new HashMap<>();

    //定义一个静态方法进行初始化
    static {
        map.put("ROLE_ROOT_ADMIN", new RootAdminRole("ROLE_ROOT_ADMIN"));
        map.put("ROLE_ORDER_ADMIN", new OrderAdminRole("ROLE_ORDER_ADMIN"));
        map.put("ROLE_NORMAL", new NormalRole("ROLE_NORMAL"));
    }

    //定义一个获取操作权限的静态方法，提供给其它方法调用
    public static RoleOperation getOp(String roleName) {
        return map.get(roleName);
    }
}

接下来借助上面这个工厂，业务代码调用也只需一行代码：

package com.gavin.factory;

public class JudgeRole02 {

    public static void main(String[] args) {
        /**
         * 使用工厂模式实现思路，先调用RoleFactory类中的getOp方法，找到对应的角色对象中的权限
         * 再调用该对象中的op()方法获取角色的权限信息
         */
        String roleName = "ROLE_ROOT_ADMIN";
        String operation = RoleFactory.getOp(roleName).op();
        System.out.println("操作权限：" + operation);
    }
}

执行结果：

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

使用策略模式

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

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

package com.gavin.strategy;

import com.gavin.enums.RoleOperation;

public class RoleContext {

    //定义可更换的策略，传入不同的策略对象，业务即相应变化
    private RoleOperation roleOperation;

    public RoleContext(RoleOperation roleOperation) {
        this.roleOperation = roleOperation;
    }

    //定义获取角色权限的方法
    public String execute() {
        return roleOperation.op();
    }
}

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

package com.gavin.strategy;

import com.gavin.enums.RoleOperation;
import com.gavin.factory.NormalRole;
import com.gavin.factory.OrderAdminRole;
import com.gavin.factory.RootAdminRole;

public class JudgeRole03 {

    public static void main(String[] args) {
        JudgeRole03 judgeRole03 = new JudgeRole03();
        String operation = judgeRole03.judge(new RootAdminRole("ROLE_ROOT_ADMIN"));
        System.out.println("operation=" + operation);
        String operation2 = judgeRole03.judge(new OrderAdminRole("ROLE_ORDER_ADMIN"));
        System.out.println("operation2=" + operation2);
        String operation3 = judgeRole03.judge(new NormalRole("ROLE_NORMAL"));
        System.out.println("operation3=" + operation3);
    }

    //定义一个方法来调用RoleContext对象中获取角色权限的execute()方法
    public String judge(RoleOperation roleOperation) {
        RoleContext roleContext = new RoleContext(roleOperation);
        return roleContext.execute();
    }
}

以上就是几种常用的if else语句的优化方法，写代码前还是得多思考一番，考虑是否有更具可扩展性的写法！