大话设计模式之简单工厂模式（Java版）

大话设计模式——第一章(简单工厂模式)

  题目：请用C++、Java、C#或VB.NET任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。

import java.io.Console;
import java.util.Scanner;

/**
 * @author zdy
 * @create 2018-11-14 22:46
 */
public class Program {
    public static void main(String args[]){
        try{
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入数字A：");
            String numberA = scanner.next();
            System.out.println("请选择运算符号（+、-、*、/）：");
            String operateSign = scanner.next();
            System.out.println("请输入数字B：");
            String numberB = scanner.next();
            String result = "";
            switch (operateSign){
                case "+":
                    result = new Double((Double.parseDouble(numberA))+(Double.parseDouble(numberB))).toString();
                    break;
                case "-":
                    result = new Double((Double.parseDouble(numberA))-(Double.parseDouble(numberB))).toString();
                    break;
                case "*":
                    result = new Double((Double.parseDouble(numberA))*(Double.parseDouble(numberB))).toString();
                    break;
                case "/":
                    if(numberB!="0")
                    {
                        result = new Double((Double.parseDouble(numberA))/(Double.parseDouble(numberB))).toString();
                    }else{
                        result = "除数不可以为0";
                    }
                    break;
                default:
                    System.out.println("你的输入有误，请重新输入");
                    return;
            }
            System.out.println("结果是："+result);
        }
        catch(Exception e){
            System.out.print("您的输入有误，请根据提示输入！");
            e.printStackTrace();
        }

    }
}

 上面的做法虽然实现计算器是没有问题但是这样的代码并不符合出题人的意思。因为出题人是要求用面向对象的思想去实现代码的，但是上面的代码则是面向过程。
 这样的程序不容易维护和扩展，更不容易复用。因此我们需要使用面向对象的思想（封装，继承，多态）去实现容易维护，容易扩展和复用的计算器程序，代码如下：

/**
 * @author zdy
 * @create 2018-11-14 23:15
 * 定义一个操作接口
 */
public class Operation {
    private double numberA;
    private double numberB;
    private double result;

    public double getNumberA() {
        return numberA;
    }

    public void setNumberA(double numberA) {
        this.numberA = numberA;
    }

    public double getNumberB() {
        return numberB;
    }

    public void setNumberB(double numberB) {
        this.numberB = numberB;
    }

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

    public void setResult(double result){
        this.result = result;
    }
}

/**
 * @author zdy
 * @create 2018-11-14 23:18
 */
public class OperationAdd extends Operation {
    @Override
    public double getResult() {

        return getNumberA()+getNumberB();
    }
}

/**
 * @author zdy
 * @create 2018-11-14 23:26
 */
public class OperationSub extends Operation {
    @Override
    public double getResult() {
        return getNumberA()-getNumberB();
    }
}

/**
 * @author zdy
 * @create 2018-11-14 23:27
 */
public class OperationMul extends Operation {
    @Override
    public double getResult() {
        return getNumberA()*getNumberB();
    }
}

/**
 * @author zdy
 * @create 2018-11-14 23:27
 */
public class OperationDiv extends Operation {
    @Override
    public double getResult() throws Exception {
        if(getNumberB()==0)
        {
            throw new Exception("除数不能为0");
        }else{
            return getNumberA()/getNumberB();
        }
    }
}

/**
 * @author zdy
 * @create 2018-11-14 23:31
 * 简单工厂模式，工厂就是考虑用一个单独的类来做这个创造实例的过程
 */
public class OperationFactory {
    public static Operation createOperate(String operate)
    {
        Operation oper = null;
        switch(operate){
            case "+":
                oper = new OperationAdd();//多态的表现形式
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

import javax.xml.transform.Result;

/**
 * @author zdy
 * @create 2018-11-14 23:35
 * 测试运行
 */
public class CalculatorTest {
    public static void main(String args[])
    {
        Operation operation = OperationFactory.createOperate("+");
        operation.setNumberA(1);
        System.out.println(operation.getNumberA());
        operation.setNumberB(2);
        System.out.println(operation.getNumberB());
        try {
            System.out.println(operation.getResult());
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

上述的代码从整体上实现了面向对象的三个特性（继承，封装，多态），以及简单工厂模式。
部分内容源自——大话设计模式