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

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

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

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

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

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

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

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

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

public enum Operator {ADD {@Overridepublic int apply(int a, int b) {return a + b;}},MULTIPLY {@Overridepublic int apply(int a, int b) {return a * b;}},SUBTRACT {@Overridepublic int apply(int a, int b) {return a - b;}},DIVIDE {@Overridepublic int apply(int a, int b) {return a / b;}},MODULO {@Overridepublic int apply(int a, int b) {return a % b;}};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);
}

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;}@Overridepublic Integer execute() {return a + b;}
}

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

public interface Rule {boolean evaluate(Expression expression);Result getResult();
}

public class AddRule implements Rule {private int result;@Overridepublic boolean evaluate(Expression expression) {boolean evalResult = false;if (expression.getOperator() == Operator.ADD) {this.result = expression.getX() + expression.getY();evalResult = true;}return evalResult;}@Overridepublic 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;}
}

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

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