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

还记得刚入门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、屏蔽产品的具体实现，用户只关心产品的接口。
缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得程序中出现大量的类，在一定程度上增加系统的复杂度。