简单工厂模式——加减乘除

还记得刚入门C语言的时候经常要写一些加加减减的程序来练练手。好吧，既然学了新语言，那就用新语言来写个简单的计算器吧！

public class Calculator {    public static void main(String[] args) {        int a,b;        Scanner scanner = new Scanner(System.in);        System.out.print("输入第一个数：");        a = scanner.nextInt();        System.out.print("输入第二个数：");        b = scanner.nextInt();        System.out.print("输入运算符：");        char op = scanner.next().charAt(0);        System.out.print("结果：");        switch (op) {            case '+':                System.out.println(a + b);                break;            case '-':                System.out.println(a - b);                break;            case '*':                System.out.println(a * b);                break;            case '/':                if (b != 0)                     System.out.println(a / b);                else                     System.out.println("除数不能为0!");                break;            default:                System.out.println("没有该运算符号！");                break;        }    }}

好吧，写到这里，相信大家都会觉得好low…，确实是这样。程序只是简单实现了加减乘除，却没有体现面向对象的思想，也没有任何的扩展性。那么，我们就引入一个新的设计模式——工厂模式。工厂模式的好处在于能够负责实现创建所有实例的内部逻辑，给程序带来更大的可扩展性和尽量少的修改量。那么且看工厂模式是如何实现上述的计算器的。

简单工厂模式

我们可以先看看简单工厂模式的UML图：

图中角色主要分为以下三类：
简单工厂类：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。
抽象产品（运算类）：简单工厂模式所创建的所有对象的父类。
具体产品（加减法类）：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。
先来看一个运算类：

public abstract class Operation {         //抽象类，运算类    public int numberA, numberB;          //运算的两个数据    abstract int getResult();             //抽象方法，返回运算结果}class AddOperation extends Operation {   //加法类    @Override    int getResult() {        return numberA + numberB;    }}class SubOperation extends Operation {   //减法类    @Override    int getResult() {        return numberA - numberB;    }}class MulOperation extends Operation {  //乘法类    @Override    int getResult() {        return numberA * numberB;    }}class DivOperation extends Operation {   //除法类    @Override    int getResult() {        if (numberB == 0) {            throw new ArithmeticException("除数不能为0");        }        return numberA / numberB;    }}

有了运算符类了，那么也要有一个生产运算符的工厂吧：

public class OperationFactory {          //运算符加工厂    public static Operation createOperate(char operate) {    //生产运算类        Operation op = null;        switch (operate) {        case '+':            op = new AddOperation();            break;        case '-':            op = new SubOperation();            break;        case '*':            op = new MulOperation();            break;        case '/':            op = new DivOperation();            break;        }        return op;    }}

再写一个计算器测试类：

public class Calculator {    public static void main(String[] args) {        Scanner scanner = new Scanner(System.in);        System.out.print("输入运算符：");        char operation = scanner.next().charAt(0);        Operation op = OperationFactory.createOperate(operation);  //通过工厂生产一个运算类        System.out.print("输入第一个数字：");        op.numberA = scanner.nextInt();        System.out.print("输入第二个数字：");        op.numberB = scanner.nextInt();        try {            System.out.print("结果：" + op.getResult());    //输出运算结果        } catch (ArithmeticException e) {            System.out.print(e.getMessage());        }       }}

看，一个简单的工厂模式就出现了。它实现了整个计算器程序的逻辑和业务上的分离。在工厂方法模式中,工厂方法用来创建各种运算符,同时还向客户端隐藏了哪种具体产品类将被实例化这一细节。而且工厂模式有良好的扩展性比如，现在我们需要再添加一种运算方式，“两个数的平方和”，那么我们只需在添加一个具体的运算类，并在运算符工厂中添加多一个case便可实现：

class squareOperation extends Operation {    @Override    int getResult() {        return numberA * numberA + numberB * numberB;    }}

当然，简单工厂模式也有其缺点。我们将其优点和缺点列举如下：
优点：
1、用户想创建一个对象，只要知道其名称就可以从工厂中获取对象。
2、扩展性高，如果想增加一个产品，只要扩展一个具体产品类就可以。
3、屏蔽产品的具体实现，用户只关心产品的接口。
缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得程序中出现大量的类，在一定程度上增加系统的复杂度。