java如何消除太多的if else判斷？

時間 2019-11-24

標籤 java 如何消除太多判斷欄目 Java 简体版

原文原文鏈接

1.簡介html

if判斷語句是不少編程語言的重要組成部分。可是，若咱們最終編寫了大量嵌套的if語句，這將使得咱們的代碼更加複雜和難以維護。java

讓咱們看看可否使用別的方式來作呢。express

設計模式是爲了更好的代碼重用性，可讀性，可靠性，可維護性，它有六大原則編程

　　　　　　1)單一職責原則（Single Responsibility Principle，簡稱SRP）:該原則是針對類來講的，即一個類應該只負責一項職責.
　　　　　　2)開放--封閉原則（The Open-Closed Principle簡稱OCP）:是說軟件實體（類、模塊、函數等等）應該能夠擴展，可是不能夠修改。
　　　　　　3)依賴倒轉原則（Dependence Inversion Principle :針對接口編程，不要對實現編程
　　　　　　4)里氏代換原則（Liskov Substitution Principle，簡稱LSP）:里氏代換原則，子類型必須可以替換掉他們的父類型
　　　　　　5)迪米特法則（Law of Demeter）:若是兩個類沒必要彼此直接通訊，那麼這兩個類就不該當發生直接的相互做用
　　　　　　6)合成/聚合複用原則（Composition/Aggregation Principle]，簡稱CARP）:儘可能使用合成/聚合，儘可能不使用類繼承。合成聚合是「has a」的關係，而繼承是「is a」的關係。設計模式

2.示例app

if..else編程語言

    public int calculate(int a, int b, String operator) {
        int result = Integer.MIN_VALUE;

        if ("add".equals(operator)) {
            result = a + b;
        } else if ("multiply".equals(operator)) {
            result = a * b;
        } else if ("divide".equals(operator)) {
            result = a / b;
        } else if ("subtract".equals(operator)) {
            result = a - b;
        } else if ("modulo".equals(operator)) {
            result = a % b;
        }
        return result;
    }

case-switchide

    public int calculateUsingSwitch(int a, int b, String operator) {
        int result = 0;
        switch (operator) {
        case "add":
            result = a + b;
            break;
        case "multiply":
            result = a * b;
            break;
        case "divide":
            result = a / b;
            break;
        case "subtract":
            result = a - b;
            break;
        case "modulo":
            result = a % b;
            break;
        default:
            result = Integer.MIN_VALUE;
        }
        return result;
    }

3.重構函數

3.1 工廠方式重構測試

抽象層Operation.java

public interface Operation {
    int apply(int a, int b);
}

加法實現Addition.java：

public class Addition implements Operation {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
}

減法實現Subtraction.java

public class Subtraction implements Operation {
        @Override public int apply(int a, int b) {
                return a - b;
        }
}

乘法實現Multiplication.java

public class Multiplication implements Operation {
        @Override public int apply(int a, int b) {
                return a*b;
        }
}

除法實現Division.java

public class Division implements Operation {
        @Override public int apply(int a, int b) {
                return a / b;
        }
}

求餘實現Modulo.java

public class Modulo implements Operation {
        @Override public int apply(int a, int b) {
                return a % b;
        }
}

工廠類OperatorFactory.java

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

public class OperatorFactory {

    static Map<String, Operation> operationMap = new HashMap<>();
    static {
        operationMap.put("add", new Addition());
        operationMap.put("divide", new Division());
        operationMap.put("multiply", new Multiplication());
        operationMap.put("subtract", new Subtraction());
        operationMap.put("modulo", new Modulo());
    }

    public static Optional<Operation> getOperation(String operation) {
        return Optional.ofNullable(operationMap.get(operation));
    }
}

使用示例

public int calculateUsingFactory(int a, int b, String operator) {
    Operation targetOperation = OperatorFactory
      .getOperation(operator)
      .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
    return targetOperation.apply(a, b);
}

3.2 枚舉方式重構

枚舉實現Operator.java

public enum Operator {

    ADD {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    },

    MULTIPLY {
        @Override
        public int apply(int a, int b) {
            return a * b;
        }
    },

    SUBTRACT {
        @Override
        public int apply(int a, int b) {
            return a - b;
        }
    },

    DIVIDE {
        @Override
        public int apply(int a, int b) {
            return a / b;
        }
    },

    MODULO {
        @Override
        public int apply(int a, int b) {
            return a % b;
        }
    };

    public abstract int apply(int a, int b);
}

封裝Operator到Calculator.java

    public int calculate(int a, int b, Operator operator) {
        return operator.apply(a, b);
    }

使用示例

@Test
public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
    assertEquals(7, result);
}

3.3 命令模式

抽象的接口

public interface Command {
    Integer execute();
}

實現類

package com.baeldung.reducingIfElse;

public class AddCommand implements Command {

    private int a;
    private int b;

    public AddCommand(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public Integer execute() {
        return a + b;
    }
}

其它略

包裝

    public int calculate(Command command) {
        return command.execute();
    }

測試demo

@Test
public void whenCalculateUsingCommand_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(new AddCommand(3, 7));
    assertEquals(10, result);
}

4.規則引擎重構

抽象規則

public interface Rule {

    boolean evaluate(Expression expression);

    Result getResult();
}

實現規則AddRule.java 其它略

public class AddRule implements Rule {

    private int result;

    @Override
    public boolean evaluate(Expression expression) {
        boolean evalResult = false;
        if (expression.getOperator() == Operator.ADD) {
            this.result = expression.getX() + expression.getY();
            evalResult = true;
        }
        return evalResult;
    }

    @Override
    public Result getResult() {
        return new Result(result);
    }
}

其中：返回結果

public class Result {
    int value;

    public Result(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

表達式

public class Expression {

        private Integer x;
        private Integer y;
        private Operator operator;

        public Expression(Integer x, Integer y, Operator operator) {
                this.x = x;
                this.y = y;
                this.operator = operator;
        }

        public Integer getX() {
                return x;
        }

        public Integer getY() {
                return y;
        }

        public Operator getOperator() {
                return operator;
        }
}

規則引擎RuleEngine.java

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class RuleEngine {

    private static List<Rule> rules = new ArrayList<>();

    static {
        rules.add(new AddRule());
    }

    public Result process(Expression expression) {

        Rule rule = rules.stream()
            .filter(r -> r.evaluate(expression))
            .findFirst()
            .orElseThrow(() -> new IllegalArgumentException("Expression does not matches any Rule"));
        return rule.getResult();
    }
}

測試demo

@Test
public void whenNumbersGivenToRuleEngine_thenReturnCorrectResult() {
    Expression expression = new Expression(5, 5, Operator.ADD);
    RuleEngine engine = new RuleEngine();
    Result result = engine.process(expression);
 
    assertNotNull(result);
    assertEquals(10, result.getValue());
}

4.比較