如何优雅地写出if else代码_if else代码例子-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_52723253/article/details/141574685

枚举类 + 策略模式 + 工厂方法 + 模板方法

最近在实习的项目中看到了这样一段代码：

// 获取type属性代码
if (type == "type_a") {
    // do something...
} else if (type == "type_b") {
    // do something...
} else if (type == "type_c") {
    // do something...
} else if (type == "type_d") {
    // do something...
} // 还有很多个if else

想必在座的各位都写过这种代码吧，对于初学者来说，只会简单地使用 if else 来处理条件分支，这样使用也有一定的好处，使用最原始的代码来进行最直白的表达，但是对于企业项目开发来说，这种代码是要不得滴，扩展性太差。

那么我们可以进行以下的改写：

switch (type) {
   case "type_a":
       // do something...
       break;
   case "type_b":
       // do something...
       break;
   case "type_c":
       // do something...
       break;
   case "type_d":
       // do something...
       break;
   default:
       // ...
       break;
}

使用 switch case 进行条件分支处理，提高程序的性能，同时让代码看起来更加优美，但是代码的扩展性还是很低，和第一种写法一样，都违背了设计模式中的开闭原则，如果我们后续有需求更改，要添加其他类型，那么就必须修改原有的代码，那我们应该怎么做呢？

这里我们就可以使用到枚举类 + 策略模式 + 工厂方法 + 模板方法来改写。具体的步骤如下：

第一步我们使用策略模式定义一个接口，将不同的业务处理抽象出一个统一的方法。

public interface UnifiedBehavior {
    
    void doSomething();
}

第二步我们去定义每一种类型的具体实现类，然后在具体子类中去实现自己的业务逻辑。

public class SpecificTypeA implements UnifiedBehavior {

    @Override
    public void doSomething() {
        System.out.println("do something about type a");
    }
}

第三步我们创建一个工厂类来获取对应的类型对象（这里还可以根据需求选择使用单例模型进行对象创建）。

public class Factory {

    public static UnifiedBehavior getInstance(String type) {
        if (type == "type_a") {
            return new SpecificTypeA();
        } else if (type == "type_b") {
            return new SpecificTypeB();
        } else if (type == "type_c") {
            return new SpecificTypeC();
        } else if (type == "type_d"){
            return new SpecificTypeD();
        } else {
            return null;
        }
    }
}

我们写一个测试类来试试看看是否可以达到预期效果：

public class Main {
    public static void main(String[] args) {
        UnifiedBehavior typec = Factory.getInstance("type_c");
        typec.doSomething();

        UnifiedBehavior typed = Factory.getInstance("type_d");
        typed.doSomething();
    }
}

在这里插入图片描述
可以看到结果和我们预期的一样，只需要两行代码就解决了，我们后续如果有新的类型添加的话也只需要新增一个子类，重写方法，修改工厂类即可。

但是这样就是最好的了吗？

不！！！还可以更好，我们发现上面的写法虽然在很大程度上保证了开闭原则，但是还是需要对工厂类进行修改，而且如果在这些子类的具体实现中如果存在公共的代码，比如权限校验，那我们有必要在每一份代码中都去写吗？那应该怎么办呢，我们继续往下迭代。

第四步我们先将不同的条件整理到一个枚举类中，每一个条件类型都对应一个枚举值。

public enum TypeEnum {
    
    TYPE_A("type_a"),
    TYPE_B("type_b"),
    TYPE_C("type_c"),
    TYPE_D("type_d");

    private final String name;
    
    TypeEnum(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    
}

第五步我们使用模板方法设计模式将之前的接口替换为抽象类，并且将代码的公共部分提取出来，并且定义一个枚举类属性。

public abstract class UnifiedBehavior {

    private final TypeEnum typeEnum;
    
    protected UnifiedBehavior(TypeEnum typeEnum) {
        this.typeEnum = typeEnum;
    }

    private void authenticate() {
        System.out.println("进行权限认证");
    }

    public void method() {
        authenticate();
        doSomething();
    }

    public abstract void doSomething();

    public TypeEnum getTypeEnum() {
        return typeEnum;
    }
}

改写具体的子类

public class SpecificTypeA extends UnifiedBehavior {

    public SpecificTypeA() {
        super(TypeEnum.TYPE_A);
    }

    @Override
    public void doSomething() {
        System.out.println("do something about type a");
    }
}

第六步改写工厂类（如果这里想要完全符合开闭原则，可以考虑使用自定义注解的方式）

public class Factory {

    private static final List<UnifiedBehavior> types = new ArrayList<>();

    private static Map<TypeEnum, UnifiedBehavior> map;
    
    private static boolean init = false;

    public static void init() {
        types.add(new SpecificTypeA());
        types.add(new SpecificTypeB());
        types.add(new SpecificTypeC());
        types.add(new SpecificTypeD());
        map = types.stream().collect(Collectors.toMap(UnifiedBehavior::getTypeEnum, Function.identity()));
        init = true;
    }
    
    public static UnifiedBehavior getInstance(TypeEnum typeEnum) {
        if (!init) {
            init();
        }
        return map.get(typeEnum);
    }
}

我们写一个测试类来试试看看是否可以达到预期效果：

public class Main {
    public static void main(String[] args) {
        UnifiedBehavior instance = Factory.getInstance(TypeEnum.TYPE_A);
        instance.method();
    }
}

在这里插入图片描述
可以看到改写后的代码也可以达到预期的效果，且具备了更好的扩展性。

如果是在spring boot项目中使用，则更加简单方便，核心是两点：

需要在每一个具体的子类上加上@Component注解，让spring去管理这个bean对象
改写工厂类，让容器去帮我们完成属性的赋值：

@Component
public class Factory {
    
    @Autowired
    private List<UnifiedBehavior> types;

    private static Map<TypeEnum, UnifiedBehavior> map;

    @PostConstruct
    public void init() {
        map = types.stream().collect(Collectors.toMap(UnifiedBehavior::getTypeEnum, Function.identity()));
    }

    public static UnifiedBehavior getInstance(TypeEnum typeEnum) {
        return map.get(typeEnum);
    }
}

我们编写一个测试类进行测试

@SpringBootTest
public class Test {

    @org.junit.jupiter.api.Test
    public void test() {
        UnifiedBehavior instancea = Factory.getInstance(TypeEnum.TYPE_A);
        instancea.method();

        UnifiedBehavior instancec = Factory.getInstance(TypeEnum.TYPE_C);
        instancec.method();
    }
}