javaif替代_在Java中替换掉繁杂的if语句
if else每种编程语⾔都不可或缺的条件语句，在编程时会⼤量的⽤到。⼀般建议嵌套不要超过三层，如果⼀段代码存在过多的嵌套，代码的可读性就会急速下降，后期维护难度也⼤⼤提⾼。
⼀、简述
通常会遇到⼀些需要做⼀系列条件处理的业务逻辑，并且它们每⼀个都需要不同的处理。来看⼀下 Calulator(计算器)类的⼀个例⼦。下⾯是带有两个数字类型参数，⼀个操作符参数以及基于操作的数值返回值的⼀个⽅法：
public int calculate(int a, int b, String operator) {
int result = Integer.MIN_VALUE;
if ("add".equals(operator)) {
result = a + b;
} else if ("subtract".equals(operator)) {
result = a - b;
} else if ("multiply".equals(operator)) {
result = a * b;
} else if ("divide".equals(operator)) {
result = a / b;
}
return result;
}
通常也能使⽤ switch 语句来操作：
public int calculate(int a, int b, String operator) {
int result = Integer.MIN_VALUE;
switch (operator) {
case "add":
result = a + b;
case "multiply":
result = a * b;
case "divide":
result = a / b;
case "subtract":
result = a - b;
break;
}
return result;
switch 语句其实并没有任何实质性的优化。嵌套条件声明编程使得程序变得难以管理。如果需要新添加⼀个操作，相应需要添加⼀个新的if 条件以及条件的实现，甚⾄需要回归整个业务代码。
经常遇见许多条件声明，它们是⽤来处理每个分⽀中相似的操作。可以提取⼀个返回具体类型的对象并且根据具体对象⾏为执⾏操作的⼯⼚类。例如，定义⼀个带有单独的 apply ⽅法的操作接⼝：
public interface CalOperation {
int apply(int a, int b);
}
单独定义业务类：
加：
public class Addition implements CalOperation {
@Override
public int apply(int a, int b) {
return a + b;
}
}
减：
public class Subtraction implements CalOperation {
@Override
java switch case stringpublic int apply(int a, int b) {
return a - b;
}
}
乘：
public class Multiplication implements CalOperation {
@Override
public int apply(int a, int b) {
return a * b;
}
}
除：
public class Division implements CalOperation {
@Override
public int apply(int a, int b) {
return a / b;
}
现在实现⼀个基于给定操作符返回相应结果的⼯程类：
public class OperatorFactory {
static Map operationMap = new HashMap<>();
//在静态块中先把初始化⼯作全部做完
static {
operationMap.put("add", new Addition());
operationMap.put("subtract", new Subtraction());
operationMap.put("multiply", new Multiplication());
operationMap.put("divide", new Division());
}
public static CalOperation getOperation(String operator) {
(operator);
}
}
在 Calculator 类中，能够通过查询⼯⼚来获取相关的操作并且应⽤于其中：
public class Calculator {
public String cal( String operator) {
// ⼀⾏代码搞定！之前的 if/else也没了！
Operation(operator).apply();
}
}
该例通过⼯⼚类来将逻辑业务责任分发委托给⼀系列轻耦合对象。但是如果只是简单地将嵌套 if 语句转移成⼯⼚类，这明显不符合预期。作为另外的选择，通过维护能够被快速查询的对象仓库map(映射)，来达成⽬的。也可以在运⾏时定义映射对象并且配置它们⽤于查。这样的话以后想扩展条件也很容易，只需要增加新代码，⽽不需要动以前的业务代码，⾮常符合“开闭原则”。
三、命令模式(command pattern)
使⽤⼯⼚类可以返回指定操作符的对应的业务对象实例，该实例⽤于 Claculator 类中执⾏计算操作。也可以设计⼀个
Calculator.calculate ⽅法来接收⼀个可以执⾏输⼊的指令。这是另外⼀种来代替嵌套 if 语句的⽅法。定义⼀个 Command 接⼝：
public interface Command {
Integer execute();
}
其中⼀个实现类 AddCommand：
public class AddCommand implements Command {
public AddCommand(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public Integer execute() {
return a + b;
}
}
最后，在 Calculator 类中定义⼀个⽤于接收操作和执⾏操作的新⽅法：
public class Calculator {
public int calculate(Command command) {
ute();
}
}
通过实例化 AddCommand 对象并且将它作为参数传递到 Calculator.calculate ⽅法当中⽤以调⽤计算⽅法：
@Test
public void whenCalculateUsingCommand_thenReturnCorrectResult() {
Calculator calculator = new Calculator();
int result = calculator.calculate(new AddCommand(3, 7));
assertEquals(10, result);
}
策略模式和⼯⼚模式写起来其实区别也不⼤！
在上⾯⼯⼚模式代码的基础上，按照策略模式的指导思想，来创建⼀个所谓的策略上下⽂类，这⾥命名为 CalContext：public class CalContext {
private CalOperation calOperation;
public CalContext(CalOperation calOperation) {
this.calOperation = calOperation;
}
public int execute(int a, int b) {
return calOperation.apply(a, b);
}
}
很明显上⾯传⼊的参数 calOperation 就是表⽰不同的“策略”。在业务代码⾥传⼊不同的⾓⾊，即可得到不同的操作结果：public class Calculator {
public int apply(int a, int b, CalOperation calOperation) {
CalContext calContext = new CalContext(calOperation);
ute(a, b);
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
int add = calculator.apply(6, 2, new Addition());
System.out.println(add);
int sub = calculator.apply(6, 2, new Subtraction());
System.out.println(sub);
int mul = calculator.apply(6, 2, new Multiplication());
System.out.println(mul);
int div = calculator.apply(6, 2, new Division());
System.out.println(div);
}
}
四、使⽤枚举
除了映射对象(map)的使⽤之外，也可以使⽤枚举来标记特定的逻辑业务。在这之后，能通过它来代替嵌套 if 语句或者 swtich 语句。作为其它处理，也可以使⽤它们作为对象⼯⼚并且整理⽤于处理相关的业务逻辑操作。这会减少嵌套 if 语句的数量并且将业务责任委托给独⽴的枚举变量中。定义⼀个枚举类：
public enum CalEnum{
ADD, SUBTRACT, MULTIPLY, DIVIDE
}
这些值是不同操作符的标签，并且会运⽤到之后的计算当中。就像嵌套 if 语句和 switch 语句那样，可以将这些值当作选项来使⽤。然⽽，可以设计⼀种能够将逻辑委托给枚举本⾝的替代⽅法，为每⼀个枚举量都定义了各⾃的⽅法并且进⾏了计算操作。例如：
CalOperation 类：
public interface CalOperation {
int apply(int a, int b);
}
CalEnum 类：
public enum CalEnum implements CalOperation {
//加
ADD {
@Override
public int apply(int a, int b) {
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论