如何封装多个if else判断

因为写android逻辑判断的时候用了太多if else而且里面的内容基本上相同，可以怎样封装来简化代码

虽然封装了，但本身的圈复杂度并没有降低，所以封装只是让代码看着简单了，那么三目运算或许比封装更好用。

通过参数的值，来进行封装，根据值的传递来确定逻辑关系

可以试试用map来去除if-else，map中放回调接口，类似于下面这样

    @FunctionalInterface
    interface Action {
        void accept(String s);
    }
    public static void main(String[] args) throws URISyntaxException {
        Map<String, Action> actionMap = new HashMap<>();
        actionMap.put("case1", (s) -> System.out.println(s));
        actionMap.put("case2", (s) -> System.out.println(s));
        actionMap.put("case3", (s) -> System.out.println(s));
        actionMap.put("case4", (s) -> System.out.println(s));
        actionMap.put("case5", (s) -> System.out.println(s));
        // 遇到某种情况就
        actionMap.get("case?").accept("xxxx");
    }

用策略模式

写了个例子，希望对你有帮助

• 我执行的样例

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        Condition.doAction("condition1");
        System.out.println();

        Condition.doAction("condition2");
        System.out.println();

        Condition.doAction("condition3");
        System.out.println();

        Condition.doAction("condition4");
        System.out.println();
    }
}

enum Condition {
    Action1("condition1", new IAction() {
        @Override
        public void action() {
            IAction.super.action();
            System.out.println(Action1.name());
        }
    }),
    Action2("condition2", new IAction() {
        @Override
        public void action() {
            IAction.super.action();
            System.out.println(Action2.name());
        }
    }),
    Action3("condition3", new IAction() {
        @Override
        public void action() {
            /*
             * 如果你的重复部分代码要求有顺序性，比如：
             * 1. 一部分重复的是一致的
             * 2. 条件特有代码
             * 3. 后一部分重复
             *
             * 这种情况可以像这里分两部分
             */

            // 执行第一部分
            commonActionPart1();

            // 执行特有
            System.out.println(Action3.name());

            // 执行第二部分
            commonActionPart2();
        }
    }),
    ;

    // if 判断条件，你是什么判断类型，就用什么类型
    final String condition;
    // 要执行的内容
    final IAction action;

    Condition(String condition, IAction action) {
        this.condition = condition;
        this.action = action;
    }

    public static void doAction(String condition) {
        // 如果都不匹配的默认值，相当于你 最后的 else
        Condition verify = Condition.Action3;
        for (Condition con : values()) {
            if (Objects.equals(con.condition, condition)) {
                verify = con;
            }
        }
        verify.action.action();
    }

    private interface IAction {
        default void action() {
            // 共用逻辑，重复的部分代码
            System.out.println("共用逻辑");
        }

        /**
         * 如果你的重复部分代码要求有顺序性，比如：
         * 1. 一部分重复的是一致的
         * 2. 条件特有代码
         * 3. 后一部分重复
         *
         * 这种情况可以像这里分两部分
         */
        default void commonActionPart1() {
            System.out.println("共用逻辑1");
        }

        default void commonActionPart2() {
            System.out.println("共用逻辑2");
        }
    }
}

重构：一个方法中最多20行代码，拆分代码，相同代码封装成方法。

1、重复的代码多，相同的代码封装一下，不少IDE有提供这个功能。特别只是状态不一样的的话，可以用switch判断，每个状态写好注释或使用优秀的变量名，然后传到封装的方法，就很直观。
3、重复代码少，如上，走策略模式， 某些场景下，类似@俺不理解 的例子，可以把方法抽象成一个个对象，使用工厂模式我觉得也不错