java如何消除太多的if else判断示例代码
1.简介
if判断语句是很多编程语言的重要组成部分。但是，若我们最终编写了大量嵌套的if语句，这将使得我们的代码更加复杂和难以维护。
让我们看看能否使用别的方式来做呢。
设计模式是为了更好的代码重用性，可读性，可靠性，可维护性，它有六大原则:
- 单一职责原则（SingleResponsibilityPrinciple，简称SRP）:该原则是针对类来说的，即一个类应该只负责一项职责.
- 开放--封闭原则（TheOpen-ClosedPrinciple简称OCP）:是说软件实体（类、模块、函数等等）应该可以扩展，但是不可以修改。
- 依赖倒转原则（DependenceInversionPrinciple:针对接口编程，不要对实现编程
- 里氏代换原则（LiskovSubstitutionPrinciple，简称LSP）:里氏代换原则，子类型必须能够替换掉他们的父类型
- 迪米特法则（LawofDemeter）:如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用
- 合成/聚合复用原则（Composition/AggregationPrinciple]，简称CARP）:尽量使用合成/聚合，尽量不使用类继承。合成聚合是“has a”的关系，而继承是“is a”的关系。
2.示例if..else
publicintcalculate(inta,intb,Stringoperator){
intresult=Integer.MIN_VALUE;
if("add".equals(operator)){
result=a+b;
}elseif("multiply".equals(operator)){
result=a*b;
}elseif("divide".equals(operator)){
result=a/b;
}elseif("subtract".equals(operator)){
result=a-b;
}elseif("modulo".equals(operator)){
result=a%b;
}
returnresult;
}
switch-case
publicintcalculateUsingSwitch(inta,intb,Stringoperator){
intresult=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;
}
returnresult;
}
3.重构
3.1工厂方式重构
抽象层Operation.java
publicinterfaceOperation{
intapply(inta,intb);
}
加法实现Addition.java：
publicclassAdditionimplementsOperation{
@Override
publicintapply(inta,intb){
returna+b;
}
}
减法实现Subtraction.java
publicclassSubtractionimplementsOperation{
@Override
publicintapply(inta,intb){
returna-b;
}
}
乘法实现Multiplication.java
publicclassMultiplicationimplementsOperation{
@Override
publicintapply(inta,intb){
returna\*b;
}
}
除法实现Division.java
publicclassDivisionimplementsOperation{
@Override
publicintapply(inta,intb){
returna/b;
}
}
求余实现Modulo.java
publicclassModuloimplementsOperation{
@Override
publicintapply(inta,intb){
returna%b;
}
}
工厂类OperatorFactory.java
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Optional;
publicclassOperatorFactory{
staticMapoperationMap=newHashMap<>();
static{
operationMap.put("add",newAddition());
operationMap.put("divide",newDivision());
operationMap.put("multiply",newMultiplication());
operationMap.put("subtract",newSubtraction());
operationMap.put("modulo",newModulo());
}
publicstaticOptionalgetOperation(Stringoperation){
returnOptional.ofNullable(operationMap.get(operation));
}
}
使用示例
publicintcalculateUsingFactory(inta,intb,Stringoperator){
OperationtargetOperation=OperatorFactory
.getOperation(operator)
.orElseThrow(()->newIllegalArgumentException("InvalidOperator"));
returntargetOperation.apply(a,b);
}
3.2枚举方式重构
枚举实现Operator.java
publicenumOperator{
ADD{
@Override
publicintapply(inta,intb){
returna+b;
}
},
MULTIPLY{
@Override
publicintapply(inta,intb){
returna*b;
}
},
SUBTRACT{
@Override
publicintapply(inta,intb){
returna-b;
}
},
DIVIDE{
@Override
publicintapply(inta,intb){
returna/b;
}
},
MODULO{
@Override
publicintapply(inta,intb){
returna%b;
}
};
publicabstractintapply(inta,intb);
}
封装Operator到Calculator.java
publicintcalculate(inta,intb,Operatoroperator){
returnoperator.apply(a,b);
}
使用示例
@Test
publicvoidwhenCalculateUsingEnumOperator_thenReturnCorrectResult(){
Calculatorcalculator=newCalculator();
intresult=calculator.calculate(3,4,Operator.valueOf("ADD"));
assertEquals(7,result);
}
3.3命令模式
抽象的接口
publicinterfaceCommand{
Integerexecute();
}
实现类
packagecom.baeldung.reducingIfElse;
publicclassAddCommandimplementsCommand{
privateinta;
privateintb;
publicAddCommand(inta,intb){
this.a=a;
this.b=b;
}
@Override
publicIntegerexecute(){
returna+b;
}
}
其它略
包装
publicintcalculate(Commandcommand){
returncommand.execute();
}
测试demo
@Test
publicvoidwhenCalculateUsingCommand_thenReturnCorrectResult(){
Calculatorcalculator=newCalculator();
intresult=calculator.calculate(newAddCommand(3,7));
assertEquals(10,result);
}
3.4规则引擎重构
抽象规则
publicinterfaceRule{
booleanevaluate(Expressionexpression);
ResultgetResult();
}
实现规则AddRule.java其它略
publicclassAddRuleimplementsRule{
privateintresult;
@Override
publicbooleanevaluate(Expressionexpression){
booleanevalResult=false;
if(expression.getOperator()==Operator.ADD){
this.result=expression.getX()+expression.getY();
evalResult=true;
}
returnevalResult;
}
@Override
publicResultgetResult(){
returnnewResult(result);
}
}
其中：返回结果
publicclassResult{
intvalue;
publicResult(intvalue){
this.value=value;
}
publicintgetValue(){
returnvalue;
}
}
表达式
publicclassExpression{
privateIntegerx;
privateIntegery;
privateOperatoroperator;
publicExpression(Integerx,Integery,Operatoroperator){
this.x=x;
this.y=y;
this.operator=operator;
}
publicIntegergetX(){
returnx;
}
publicIntegergetY(){
returny;
}
publicOperatorgetOperator(){
returnoperator;
}
}
规则引擎RuleEngine.java
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Optional;
importjava.util.stream.Collectors;
publicclassRuleEngine{
privatestaticListrules=newArrayList<>();
static{
rules.add(newAddRule());
}
publicResultprocess(Expressionexpression){
Rulerule=rules.stream()
.filter(r->r.evaluate(expression))
.findFirst()
.orElseThrow(()->newIllegalArgumentException("ExpressiondoesnotmatchesanyRule"));
returnrule.getResult();
}
}
测试demo
@Test
publicvoidwhenNumbersGivenToRuleEngine_thenReturnCorrectResult(){
Expressionexpression=newExpression(5,5,Operator.ADD);
RuleEngineengine=newRuleEngine();
Resultresult=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如何消除太多的ifelse判断的文章就介绍到这了,更多相关javaifelse判断内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！