if else语句的优化

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);
    }
}

if else语句的优化
而且这样一来,以后我想扩充条件,只需要去枚举类中加代码即可

使用工厂模式

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

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

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);
    }
}

执行结果:
if else语句的优化
这样的话以后想扩展条件也很容易,只需要增加新代码,而不需要动以前的业务代码,非常符合“开闭原则”。

使用策略模式

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

在上面工厂模式代码的基础上,按照策略模式的指导思想,我们也来创建一个所谓的策略上下文类,这里命名为 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语句的优化方法,写代码前还是得多思考一番,考虑是否有更具可扩展性的写法!

上一篇:使用GO语言灵活批量ssh登录服务器执行操作


下一篇:PHP 2:从一个实例介绍学习方法