《大话设计模式》——1.简单工厂设计模式

需求：用Java实现简单计算器

1.0基础实现：业务和界面分离

public class Operation {

    public static double GetResult(double numberA, double numberB, String operate) {
        double result = 0d;
        switch (operate) {
            case "+":
                result = numberA + numberB;
                break;
            case "-":
                result = numberA - numberB;
                break;
            case "*":
                result = numberA * numberB;
                break;
            case "/":
                result = numberA / numberB;
                break;
        }
        return result;
    }

    public static void main(String[] args) {
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.print("请输入数字A：");
            String strNumberA = br.readLine();
            System.out.print("请选择运算符号（+、-、*、/）：");
            String strOperate = br.readLine();
            System.out.print("请输入数字B：");
            String strNumberB = br.readLine();

            //结果
            Double strResult = 0d;
            strResult = GetResult(Double.parseDouble(strNumberA), Double.parseDouble(strNumberB), strOperate);
            System.out.println("结果：" + strResult);
        } catch (Exception e) {
            System.out.println("您的输入有误：" + e.getMessage());
        }
    }
}

2.0 进阶实现：封装继承多态

通过子类去重写父类的getResult方法实现。

//父类
public class Operation {
    public double NumberA = 0;
    public double NumberB = 0;

    public double getNumberA() {
        return NumberA;
    }

    public void setNumberA(double numberA) {
        NumberA = numberA;
    }

    public double getNumberB() {
        return NumberB;
    }

    public void setNumberB(double numberB) {
        NumberB = numberB;
    }

    public double getResult() throws Exception {
        double result = 0;
        return result;
    }

}
//子类：加法
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        return NumberA + NumberB;
    }
}

//子类：减法
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return NumberA - NumberB;
    }
}

//子类：乘法
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return NumberA * NumberB;
    }
}

//子类：除法
public class OperationDiv extends Operation {
    @Override
    public double getResult() throws Exception {
        if (NumberA == 0) {
            throw new Exception("除数不能为0");
        }
        return NumberA / NumberB;
    }
}

3.0 最终实现：简单运算工厂类

在进阶实现的基础上增加工厂类，实现输入运算符号，工厂就实例化合适的对象，通过多态返回父类的方式实现了计算器结果。
后续如果有新的需求要进行修改时，只需要修改相应的子类；如果有新增运算符号，只需写好相应的子类并在工厂类里增加swich分支即可。

public class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new OperationAdd();
                break;
            case "-":
                operation = new OperationSub();
                break;
            case "*":
                operation = new OperationMul();
                break;
            case "/":
                operation = new OperationDiv();
                break;
        }
        return operation;
    }

    public static void main(String[] args) throws Exception {
        Operation operation;
        operation = OperationFactory.createOperate("+");
        operation.NumberA = 1;
        operation.NumberB = 2;
        System.out.println("加法：" + operation.getResult());
    }
}

总结

简单工厂模式就是对具体实现类进行封装，实现低耦合。
就案例中的计算器来举例：
如果是普通的模式增加一个开方的功能，得在核心代码里进行修改，风险非常大。
但是如果采用工厂模式，只需要增加一个开方的子类去继承操作这个父类，然后修改工厂类，不会变动核心代码。

番外（个人理解，请大家指正）

举个简单的例子：
小米开了一家奶茶店，生意火爆之后开了很多分店。但是小米只有一个人，该如何实现多家分店产品同步呢？
①简单工厂模式：小米所在门店改造为工厂，为每家分店输送奶茶成品，分店只负责卖无关口味的更新。
②普通模式：当奶茶口味出现变化时，每家奶茶店都要自己根据配方更新。

如果奶茶口味更新
实际：普通模式在现实中并无不妥，毕竟很多店铺都采用调整配方实现奶茶口味同步。
计算机：但是在代码中相当于每个实现类都要copy一遍更新配方，是一个重复操作的过程。
如果奶茶的生产通过奶茶工厂完成，就会减少重复操作，降低耦合。