Java 中替代 if else

copy 的其他博主的，後續弄懂了，會進行大幅度修改

參考博客： Java中的大量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;
    }
    return result;
}

二、簡單替代 switch

public int calculateUsingSwitch(int a, int b, String operator) {
    switch (operator) {
    case "add":
        result = a + b;
        break;
    // other cases    
    }
    return result;
}

三、複雜替代

1. 工廠類

• 抽象接口：

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

• 實現方法：

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

• 工廠提供操作：

  public class OperatorFactory {
  	static Map<String, Operation> operationMap = new HashMap<>();
  	static {
      	operationMap.put("add", new Addition());
      	operationMap.put("divide", new Division());
      	// more operators
  	}
  
  public static Optional<Operation> getOperation(String operator) {
      return Optional.ofNullable(operationMap.get(operator));
  }
  

• 調用：

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

2. 枚舉

• 枚舉中定義操作：

  public enum Operator {
  	ADD, MULTIPLY, SUBTRACT, DIVIDE
  }
  

• 編寫抽象方法：

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

• 調用時傳入枚舉值：

  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. 命令模式

• 定義命令接口：

  public interface Command {
  	Integer execute();
  }
  

• 實現加法：

  public class AddCommand implements Command {
  	// Instance variables
  
  	public AddCommand(int a, int b) {
      	this.a = a;
      	this.b = b;
  	}
  
  	@Override
  	public Integer execute() {
      	return a + b;
  	}
  }
  

• 定義Calculator類，加入執行命令的方法：

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

• 測試：

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

• 實現規則引擎：

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

• 定義表達式：

  public class Expression {
  	private Integer x;
  	private Integer y;
  	private Operator operator;        
  }
  

• 定義加法規則：

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

• 測試：

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