简单工厂模式

需求

假设我们有个需求是实现加减乘除运算的，需要我们编程代码去实现他。

代码实现

先上代码
操作相关的类

/**
 * 所有运算操作的父类
 * */
interface Operation{
    BigDecimal GetResult(int numA,int numB);
}

/**
 * + 操作
 * */
class OperationAdd implements Operation{
    @Override
    public BigDecimal GetResult(int numA, int numB) {
        return BigDecimal.valueOf(numA+numB);
    }
}

/**
 * - 操作
 * */
class OperationSub implements Operation{
    @Override
    public BigDecimal GetResult(int numA, int numB) {
        return BigDecimal.valueOf(numA-numB);
    }
}

/**
 *  * 操作
 * */
class OperationMul implements Operation{
    @Override
    public BigDecimal GetResult(int numA, int numB) {
        return BigDecimal.valueOf(numA*numB);
    }
}

/**
 *  / 操作
 * */
class OperationDiv implements Operation{
    @Override
    public BigDecimal GetResult(int numA, int numB) {
        return BigDecimal.valueOf(numA/numB);
    }
}

工厂类

/**
 * 工厂类
 * */
public class Factory {

    /**
     * 根据传入的运算符，返回相对应的对象
     * */
    public static Operation getInstance(String operationStr) throws Exception {
        Operation operation;
        switch (operationStr){
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
            default:
                throw new Exception("没有符合的运算");
        }
        return operation;
    }

}

使用示范

public static void main(String[] args){
        Operation operation = null;
        try {
            operation = Factory.getInstance("+");
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(null != operation){
            BigDecimal result = operation.GetResult(1,2);
            System.out.println("结果："+result);
        }

    }

运行结果

好处

代码看完了，我们来看看为什么要这样写，明明一个方法能解决的事情为什么要弄出来那么多个类？
我们现在假设有两种情况，一种是全部写在一个方法中，像这样：

public BigDecimal getResult(int numA,int numB,String operationStr) throws Exception {
        switch (operationStr){
            case "+":
                return BigDecimal.valueOf(numA+numB);
            case "-":
                return BigDecimal.valueOf(numA-numB);
            case "*":
                return BigDecimal.valueOf(numA*numB);
            case "/":
                return BigDecimal.valueOf(numA/numB);
            default:
                throw new Exception("没有符合的运算");
        }
    }

我们就称它为A解决方案
自然，简单工厂就是B解决方案

可扩展性

需求：假如我现在需要在加一种运算，如：根号
A解决方案：
怎么做：在getResult方法中增加一个switch分支
好处：方便，直接加就好了
缺点：需要改动已有代码，可能会出现各种问题
B解决方案：
怎么做：新增一个类实现Operation父类，实现GetResult方法，在switch中增加一个分支
好处：不需要对已有的业务代码进行改动
缺点：麻烦，需要新增一个类

可维护性

需求：假如说，我现在需要将 / 运算结果四舍五入取整
A解决方案：
怎么做：在switch的+分支下进行改动
好处：方便
缺点：需要改动已有代码，可能会出现各种问题
B解决方案：
怎么做：到OperationAdd类中，修改代码
好处：不需要对已有的业务代码进行改动
缺点：好像没什么缺点(如果说要去找这个OperationAdd类，麻烦，那也算一个缺点吧)

耦合度

A解决方案：这个看看就知道，全部代码都写在一起，耦合度当然高
B解决方案：分成一个个类，一个个方法，降低了耦合度

总结

可能因为需求太小，很多人还是任务，A的解决方案很不错，但是，正常项目中不可能一个需求两行代码就解决了，需要大量的业务代码，如果全部都写在同一个方法中，到时候找起来就很难找，而且很容易牵一发而动全身，因此，到底哪种方法好，就自己看吧，毕竟打代码只是实现一个功能的方式而已，你也可以用其他方式去实现他。