1、问题
在工作中我们可能会遇到一些多判断的复杂场景，这样会产生很多if else问题。在我的开发习惯中，如果if else超过三个，可能就会去想办法能不能优化一下。
2、解决方案
网上有很多解决方法，我自己常用的有两种方式。一种是枚举，另一种就是策略模式,这里策略模式可以和工厂模式结合使用。
先说下我分别在什么场景下会用它们：
如果if else里面的逻辑不是很复杂的话，我会选择用枚举方式解决。
如果逻辑比较复杂，我会选择用策略模式解决。
因为策略模式会产生很多类，所以我一般优先选择枚举方式。
2.1、枚举
新建一个枚举类：
public abstract void handler(Integer paramType);是我们的处理方法，每个枚举都要实现这个方法，然后在对应的实现方法里处理业务逻辑。
package com.example.test.enums;
/**
* @author murphy
*/
public enum TestEnum {
TEST1(1,"情形1的处理逻辑"){
@Override
public void handler(Integer paramType) {
System.out.println("当前参数:" + paramType + ",当前处理逻辑:" + this.getTypeName());
}
},
TEST2(2,"情形2的处理逻辑"){
@Override
public void handler(Integer paramType) {
System.out.println("当前参数:" + paramType + ",当前处理逻辑:" + this.getTypeName());
}
},
TEST3(3,"情形3的处理逻辑"){
@Override
public void handler(Integer paramType) {
System.out.println("当前参数:" + paramType + ",当前处理逻辑:" + this.getTypeName());
}
};
private Integer type;
private String typeName;
TestEnum(Integer type, String typeName) {
this.type = type;
this.typeName = typeName;
}
public static TestEnum getEnumByType(Integer type) {
for (TestEnum testEnum : TestEnum.values()) {
if (testEnum.getType().equals(type)) {
return testEnum;
}
}
return null;
}
public abstract void handler(Integer paramType);
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
public String getTypeName() {
return typeName;
}
public void setTypeName(String typeName) {
this.typeName = typeName;
}
}调用：
@Test
void test1() {
//条件
Integer paramType = 1;
//普通if else判断
if(paramType == 1){
System.out.println("情形1的处理逻辑");
}else if(paramType == 2){
System.out.println("情形2的处理逻辑");
} else if (paramType == 3) {
System.out.println("情形3的处理逻辑");
}
//枚举优化后
TestEnum.getEnumByType(paramType).handler(paramType);
}运行结果：
通过结果，我们可以看到，枚举优化后的处理结果和普通方式if else判断后的结果是一样的。
2.2、策略模式
我们先说一下策略模式的主要角色：
策略接口（Strategy Interface）：定义算法的公共接口。
具体策略类（Concrete Strategy Classes）：实现策略接口的不同算法。
上下文类（Context Class）：持有一个策略对象，客户端通过上下文类来调用具体的策略。
定义策略接口：
public interface Strategy {
void execute();
}实现具体策略类：
package com.example.test.service.impl;
import com.example.test.service.Strategy;
public class StrategyA implements Strategy {
@Override
public void execute() {
System.out.println("A条件下的执行逻辑");
}
}package com.example.test.service.impl;
import com.example.test.service.Strategy;
public class StrategyB implements Strategy {
@Override
public void execute() {
System.out.println("B条件下的执行逻辑");
}
}上下文类：
package com.example.test.context;
import com.example.test.service.Strategy;
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}动态选择策略，我们可以结合工厂模式来选择具体的策略类
创建策略工厂：
package com.example.test.factory;
import com.example.test.service.Strategy;
import com.example.test.service.impl.StrategyA;
import com.example.test.service.impl.StrategyB;
import java.util.HashMap;
import java.util.Map;
/**
* 策略模式工厂
* @author murphy
* @date 2024/6/10
*/
public class StrategyFactory {
private static Map<String, Strategy> strategies = new HashMap<>();
static {
strategies.put("A", new StrategyA());
strategies.put("B", new StrategyB());
}
public static Strategy getStrategy(String type) {
return strategies.get(type);
}
}调用：
@Test
void test2() {
Context context = new Context();
// 根据不同条件动态选择策略
String condition = "A";
Strategy strategy = StrategyFactory.getStrategy(condition);
if (strategy != null) {
context.setStrategy(strategy);
context.executeStrategy();
} else {
System.out.println("Invalid strategy type");
}
}执行结果：
