简单工厂设计模式

需求：用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());
    }
}