设计模式-简单工厂模式

要求:实现一个计算器的功能
代码一：

计算类：
public class Caculator {
    public Double calcuate(Double valueA,Double valueB,String operation) {
        Double result = Double.parseDouble("0");
        switch (operation) {
            case "+":
                result = valueA + valueB;
                break;
            case "-":
                result = valueA - valueB;
                break;
            case "*":
                result = valueA * valueB;
                break;
            case "/":
                if (valueB == 0) {
                    throw new RuntimeException("被除数不能为零");
                } else {
                    result = valueA / valueB;
                }
                break;
        }
        return result;
    }
}

输入类：
public class Program {
    public static void main(String[] args)  {
        System.out.println("请输入第一个数字：");
        Scanner scA = new Scanner(System.in);
        String valueA = scA.nextLine();

        System.out.println("请输入第二个数字：");
        Scanner scB = new Scanner(System.in);
        String valueB = scB.nextLine();

        System.out.println("请输入运算符：");
        Scanner scC = new Scanner(System.in);
        String valueC = scC.nextLine();
        Double result = (double) 0;
        Caculator caculator = new Caculator();
        try {
            result = caculator.calcuate(Double.parseDouble(valueA), Double.parseDouble(valueB), valueC);
        } catch (Exception e) {
            System.out.println("请检查您的输入" + e.getMessage());
        }

        System.out.println(result);
    }
}

问题：
这样写有什么问题：
1、面向对象的封装、继承、抽象、多态没用到，这可能是很多初学者的感觉吧
2、实现了加减乘除，如果需要再加一个求平方的呢，需要改本来运行良好的代码。

优秀的代码：可维护，可复用，可扩展。
这样的代码好维护吗，能复用吗，扩展性强吗？
面向的对象的核心，就是封装，继承，抽象，多态，我们一样也没用，怎么能谈的上可维护，可复用，可扩张呢

代码二：

共有的抽象成父类：
public  abstract class Operation {
    protected double numberA=0;
    protected double numberB=0;
    public  abstract double getResult();
}

加法：
public class OperationAdd extends Operation {
    @Override
    public double getResult() {
        return numberA+numberB;
    }
}

减法：
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return numberA-numberB;
    }
}

两种算法都有了，两种算法都是独立，维护各自的，对其他不影响，新增算法对原有的不影响，
需要那个new 那个就好了

其实对于客户端来说不需要这么多：


public class OperationFactory {
    private  Operation operation=null;

    public  Operation getOperation(String code){
        if(null==code)return null;
        switch (code){
            case "+":
                operation=new OperationAdd();
                break;
            case "-":
                operation=new OperationSub();
                break;
        }
        return operation;
    }
}

客户端调用

public class ClientDemo {
    public static void main(String[] args) {
        OperationFactory factory = new OperationFactory();
        Operation operation = factory.getOperation("-");
        operation.numberA = 1;
        operation.numberB = 2;
        System.out.println(operation.getResult());
    }
}

这就是简单工程模式：
可见有三个组成部分，1、工厂用来创建对象2、具体的计算类3、抽象出来的计算类（抽取公共部分，并确保具体计算类都是同一种类型）
对于客户端来说，只需要自己需要那种算法即可。
对于代码来说，维护不相互影响，增加算法不会设计本来有的算法。

------参考《大话设计模式–程杰》