加入收藏 | 设为首页 |

徐志摩的诗-Java中多个ifelse句子的代替规划

海外新闻 时间: 浏览:162 次

概述

ifelse是任何编程言语的重要组成部分。可是咱们编写了许多嵌套的if句子,这使得咱们的代码愈加杂乱和难以保护。

接下来,让咱们探究怎么简化代码的中的ifelse句子写法。

事例研讨

咱们常常遇到触及许多条件的事务逻辑,而且每个逻辑都需求不同的处理方式。以Calculator类为例。咱们将有一个办法,它承受两个数字和一个运算符作为输入,并依据操作回来成果:

咱们也能够运用switch句子来完成它:

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

在典型的开发中,if句子或许会变得更大,更杂乱。此外,当存在杂乱条件时,switch句子不适合。

具有嵌套决议计划结构的另一个副作用是它们变得难以办理。例如,假如咱们需求增加一个新的运算符,咱们有必要增加一个新的if句子并完成该操作。

重构

能够经过规划形式,来到达咱们要的作用。

工厂形式

许多时分,咱们遇到ifelse结构,终究在每个分支中履行相似的操作。这供给了提取工厂办法的时机,该工厂办法回来给定类型的目标并依据详细目标行为履行操作。

关于咱们的示例,让咱们界说一个具有单个apply办法的Operation接口:

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

该办法将两个数字作为输入并回来成果。让咱们界说一个用于履行增加的类:

public class Addition implements Operatio徐志摩的诗-Java中多个ifelse句子的代替规划n {
@Override
public int apply(int a, int b) {
return a + b;
}
}

咱们现在将完成一个工厂类,它依据给定的运算符回来Operation的实例:

public class OperatorFactory {
static Map operationMap = new HashMap<>();
static {
operationMap.put("add", new Addition());
operationMap.put("divide", new Division());
// more operators
}

public static Optional getOperation(String operator) {
return Optional.ofNullable(operationMap.get(operator));
}
}

现在,在Calculator类中,咱们能够查询工厂以获取相关操作并运用源数:

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

在这个比如中,咱们现已看到了怎么将职责托付给工厂类供给的松懈耦合目标。可是有或许嵌套的if句子仅仅搬运到了工厂类,这违反了咱们的意图。

或许,咱们能够在Map中保护一个目标存储库,能够查询该存储库以进行快速查找。正如咱们所见,OperatorFactory#operationMap服务于咱们的意图。咱们还能够在运行时初始化Map并将它们装备为查找。

运用枚举

除了运用Map之外,咱们还能够运用Enum来符号特定的事务逻辑。之后,咱们能够在嵌套的if句子或switch case 句子中运用它们。或许,咱们也能够将它们用作目标的工厂并拟定战略以履行相关的事务逻辑。

这样能够削减嵌套if句徐志摩的诗-Java中多个ifelse句子的代替规划子的数量,并将职责托付给单个Enum值。

让咱们看看咱们怎么完成它。首要,咱们需求界说咱们的枚举:

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

能够观察到,这些值是不同运算符的标签,将进一步用于核算。咱们总是能够挑选在嵌套的if句子或switch case中运用这些值作为不同的条件,但让咱们规划一种将逻辑托付给Enum自身的代替办法。

咱们将为每个Enum值界说办法并进行核算。例如:

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

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

然后在Calculator类中,咱们能够界说一个履行操作的办法:

publ陈坤微博ic int calculate(int a, int b, Operator operator) {
return operator.apply(a, b);
}

现在,咱们能够经过运用Operator#valueOf()办法将String值转换为Operator来调用该办法:

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

指令形式

在前面的评论中,咱们现已看到运用工厂类来回来给定运算符的正确事务目标的实例。稍后,事务目标用于在核算器中履行核算。

咱们还能够规划一个Calculator#calculate办法来承受能够在输入上履行的指令。这将是替换嵌套if句子的另一种办法。

咱们首要界说咱们的Command接口:

public i徐志摩的诗-Java中多个ifelse句子的代替规划nterface Command {
Integer execute();
}

接下来,让咱们完成一个AddCommand:

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中引进一个承受并履行Command的新办法:

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

接下来,咱们能够经过实例化AddCommand调用核算并将其发送到Calculator#calculate办法:

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

规矩引擎

当咱们终究编写许多嵌套if句子时,每个条件都描绘了一个事务规矩,有必要对其进行评价才干处理正确的逻辑。规矩引擎从主代码中获取了这种杂乱性。一个RuleEngine评价规矩和回来依据输入的成果。

让咱们经过规划一个简略的RuleEngine来演示一个比如,该RuleEngine经过一组规矩处理Expression并回来所选规矩的成果。首要,咱们将界说一个Rule接口:

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

其次,让咱们完成一个RuleEngine:

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

所述RuleEngine承受一个表达目标,并回来成果。现在,让咱们将Expression类规划为一组包括两个Integer目标的Operator,它将被运用:

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

终究让咱们界说一个自界说的AddRule类,该类仅在指定ADD操作时进行求值:

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

咱们现在将运用Expression调用RuleEngine:

@Test
public void test() {
Expression expression = new Expression(5, 5, Operator.ADD);
RuleEngine engine = new RuleEngine();
Result result = engine.process(expression);

assertNotNull(result);
徐志摩的诗-Java中多个ifelse句子的代替规划assertEquals(10, result.getValue());
}

定论

经过这些规划形式,能够作为咱们的ifelse句子的代替计划,详细用哪一种能够依据你的实践事务场景来决议。