基于工厂模式的代码

2023.6.29

今天花费了时间去写了一个基于工厂模式的代码重构的demo，因为在不久之前的一次面试当中，面试官有问到代码重构相关的知识点，瞬间又多了一个知识薄弱点，那就简单总结一下对于代码重构方向的简单理解。

public int calculate(int a, int b, String operator) {
    int result = Integer.MIN_VALUE;
 
    if ("add".equals(operator)) {
        result = a + b;
    } else if ("multiply".equals(operator)) {
        result = a * b;
    } else if ("divide".equals(operator)) {
        result = a / b;
    } else if ("subtract".equals(operator)) {
        result = a - b;
    }
    return result;
}

上面的代码是重构前的代码，供大家参考一下，大家也可以自行发挥去重构这段代码，从表面来看的话，起什么没什么大问题，但是我们考虑问题一定要全面，没有做空值处理以及代码的结构存在冗余，不方便空能的拓展等。。

下面我们我们代码进行重构 ， 常用的重构是基于工厂模式实现 ， 核心思想是将功能封装成功能类，实现一个带有空值处理的操作工厂类：

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public interface Operation {   //定义工厂接口
    int apply(int a , int b);
}

/*
*定义操作类  add   ,  功能增加区
* */
class Addition implements Operation{
    @Override
    public int apply(int a , int b){
        return a+b;
    }
}

class Division implements Operation{
    @Override
    public int apply(int a , int b){
        return a-b;
    }
}

/*
* 实现操作工厂
* */
class OperationFactory{
    static Map<String, Operation> operationMap = new HashMap<String, Operation>();

    static {
        operationMap.put("add", new Addition());
        operationMap.put("divide" , new Division());
    }
    public static Optional<Operation> getOperation(String  Operator) {
        return Optional.ofNullable(operationMap.get(Operator));
    }
}

功能类引用：

class Calcuate {
    int culateUsingFactory(int a , int b , String operator){
        Operation targetOperation = OperationFactory
                .getOperation(operator)
                .orElseThrow(() -> new IllegalArgumentException("Invaild Operation"));  //自定义异常
        //orElseThrow()如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
        return targetOperation.apply(a , b);
    }

    public static void main(String[] args) {
        Calcuate c = new Calcuate();
        System.out.println(c.culateUsingFactory(100 , 2 , "add"));
    }
}

在操作工厂类中用Optional获取操作对象，在实现类当中用orElseThrow判断获取对象是否起作用

大概总结一下，代码重构的核心思想就是将冗余或者重复不便于拓展的代码重新设计成为可读性高，便于拓展的代码。