java消除大量的ifelse判断的方法

这篇文章主要讲解了java消除大量的if else判断的方法，内容清晰明了，对此有兴趣的小伙伴可以学习一下，相信大家阅读完之后会有帮助。

创新互联服务项目包括兴业网站建设、兴业网站制作、兴业网页制作以及兴业网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，兴业网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到兴业省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

1.简介

if判断语句是很多编程语言的重要组成部分。但是，若我们最终编写了大量嵌套的if语句，这将使得我们的代码更加复杂和难以维护。

让我们看看能否使用别的方式来做呢。

设计模式是为了更好的代码重用性，可读性，可靠性，可维护性，它有六大原则:

单一职责原则（Single Responsibility Principle，简称SRP）:该原则是针对类来说的，即一个类应该只负责一项职责.
开放--封闭原则（The Open-Closed Principle简称OCP）:是说软件实体（类、模块、函数等等）应该可以扩展，但是不可以修改。
依赖倒转原则（Dependence Inversion Principle :针对接口编程，不要对实现编程
里氏代换原则（Liskov Substitution Principle，简称LSP）:里氏代换原则，子类型必须能够替换掉他们的父类型
迪米特法则（Law of Demeter）:如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用
合成/聚合复用原则（Composition/Aggregation Principle]，简称CARP）:尽量使用合成/聚合，尽量不使用类继承。合成聚合是“has a”的关系，而继承是“is a”的关系。

2.示例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;
}

switch-case

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

3.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 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.比较

重构方式	SRP	OCP	DIP	LSP	LD	CARP
IF/ELSE	N	N	N	N	N	N
工厂方法	Y	Y	Y	Y	Y	Y
枚举方法	N	Y	Y	Y	Y	Y
命令模式	Y	Y	Y	Y	Y	Y
规则引擎	Y	Y	Y	Y	Y	Y

5.小结

　为了更好的代码重用性，可读性，可靠性，可维护性，我们会尝试将IF/ELSE或者case-switch进行改造，使用工厂方法，枚举方法，命令模式，规则引擎方式不同方法进行尝试，最后使用设计模式的六大原则对代码进行评估。

看完上述内容，是不是对java消除大量的if else判断的方法有进一步的了解，如果还想学习更多内容，欢迎关注创新互联行业资讯频道。

分享名称：java消除大量的ifelse判断的方法
分享路径：http://cxhlcq.com/article/gdssoj.html

java消除大量的ifelse判断的方法

其他资讯

网站制作

企业服务

网站建设

服务器托管