如何优化递进式判断代码？

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《如何优化递进式判断代码？》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

优化递进式判断代码的两种方案

给定代码中递进式判断存在冗余，可以通过两种优化方案来改善：

方案一：利用位向量

将字符判断结果用位向量表示：

/**
 * 都不为空
 */
private static final int code_condition_one = 0000;

/**
 * abc不为空 d为空
 */
private static final int code_condition_two = 0001;

private static final int code_condition_three = 0011;

private static final int code_condition_four = 0111;

private static final int code_condition_five = 1111;

然后重构方法如下：

private static void test(string a,string b,string c,string d){
    switch (init(a,b,c,d)){
        case code_condition_one:
            // do something ...
            break;
        case code_condition_two:
            //do something ...
            break;
        case code_condition_three:
            //do something ...
            break;
        case code_condition_four:
            //do something ...
            break;
        case code_condition_five:
            //do something ...
            break;
    }
}

private static int init(string ... allparam){
    if(allparam == null){
        return 1;
    }
    string resultnumberstr = "";
    for (string s : allparam) {
        resultnumberstr += stringutils.isnotempty(s) ? 0 : 1;
    }
    return integer.valueof(resultnumberstr);
}

方案二：反射+指令映射表

@Getter
class SolutionTwo{

    private static Object result;

    @Data
    private static class Action{
        /**
         * 目标类
         */
        private Class targetInvokeClass;

        /**
         * 目标类中目标方法
         */
        private String targetMethodName;

        /**
         * 参数类型
         */
        private Class[] parameterTypes;

        /**
         * 目标方法参数对象
         */
        private Object[] params;

        /**
         * 是否是当前类中方法
         */
        private boolean isCurrentClass;

        /**
         * 是否方法不需要参数
         */
        private boolean isNoParams;

        public Action(){

        }

        public Action(Class targetInvokeClass, String targetMethodName,Class[] parameterTypes, Object[] params, boolean isCurrentClass, boolean isNoParams) {
            this.targetInvokeClass = targetInvokeClass;
            this.targetMethodName = targetMethodName;
            this.parameterTypes = parameterTypes;
            this.params = params;
            this.isCurrentClass = isCurrentClass;
            this.isNoParams = isNoParams;
        }
    }

    /**
     * 映射Map
     * 泛型Object是指令,
     * 泛型Action是指令对应的执行方案
     */
    private static final HashMap<Object,Action> ACTION_MAP = new HashMap<>(16);

    static class ResultAction{

        public void helloWorld(String name){
            System.out.println(name + ",你好世界");
        }

    }


    static {
        //都不为空
        ACTION_MAP.put(0,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是张三"},false,false));
        //abc不为空 d为空
        ACTION_MAP.put(1,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是李四"},false,false));
        //ab不为空 cd为空
        ACTION_MAP.put(11,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是王五"},false,false));
        //a不为空 bcd为空
        ACTION_MAP.put(111,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是赵六"},false,false));
        //abcd都为空
        ACTION_MAP.put(1111,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是张三他爹"},false,false));
    }

    private static void test(String a,String b,String c,String d){
        int result = init(a, b, c, d);
        Action action = ACTION_MAP.get(result);
        if(action != null){
            handler(action);
        }else{
            System.out.println("未找到对应映射键");
        }
    }

    private static void handler(Action action) {
        try {
            Method method = null;
            Class cls = null;
            if (action.isCurrentClass()) {
                method = getMethod(SolutionTwo.class,action.getTargetMethodName(),action.getParameterTypes());
                cls = SolutionTwo.class;
            }else{
                Class targetClass = action.getTargetInvokeClass();
                method = getMethod(targetClass, action.getTargetMethodName(), action.getParameterTypes());
                cls = action.getTargetInvokeClass();
            }
            result = method.invoke(cls.newInstance(), action.getParams());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            e.printStackTrace();
        }
    }


    private static Method getMethod(Class cls,String methodName,Class[] parameterTypes) throws NoSuchMethodException {
        return cls.getMethod(methodName,parameterTypes);
    }


    private static int init(String ... allParam){
        if(allParam == null){
            return 1;
        }
        String resultNumberStr = "";
        for (String s : allParam) {
            resultNumberStr += StringUtils.isNotEmpty(s) ? 0 : 1;
        }
        return Integer.valueOf(resultNumberStr);
    }
}

好了，本文到此结束，带大家了解了《如何优化递进式判断代码？》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！