简单工厂

最近读了《大话设计模式》一书，觉得里面讲解的简单工厂十分不错，在此加上自己的理解分享给大家。

一道简单的面试题

小菜去面试，面试题是“输入两个数字和一个运算符号，使用面向对象语言编写程序求出结果”。题目比较简单，小菜花了10分钟就写出了如下代码：

public static double count(double firstNumber, double secondNumber, String mark) throws Exception {
    switch (mark) {
    case "+":
        return firstNumber + secondNumber;
    case "-":
        return firstNumber - secondNumber;
    case "*":
        return firstNumber * secondNumber;
    case "/":
        if (secondNumber == 0) {
            throw new Exception("除数不能为0");
        }
        return firstNumber / secondNumber;
    default:
        throw new Exception("该运算类型暂不支持");
    }
}

但是小菜面试被淘汰了！
从上面的代码来看，完成了计算的功能，并且也考虑到了程序的容错性。但是面试题怎么可能这么简单？小菜被淘汰的原因是没有弄懂面试官的意图，忽略了题目中非常重要的“面向对象”四个字。上面这个函数虽然实现了功能，但是可扩展性和可复用性都没有，思想仍然停留在“面向过程”的变成思想。假如让你再实现一个求平方的功能，就只能修改源代码增加case语句，这违反了面向对象的开闭原则-对增加代码开放，对修改代码封闭。

使用面向对象编程思想

于是小菜又使用面向对象的方法写出了如下代码：

interface Calculate{
    double count(double firstNumber, double secondNumber);
}

class Add implements Calculate{

    @Override
    public double count(double firstNumber, double secondNumber) {
        return firstNumber + secondNumber;
    }
    
}

class Reduce implements Calculate{

    @Override
    public double count(double firstNumber, double secondNumber) {
        return firstNumber - secondNumber;
    }
    
}
//乘法和除法的两个类省略...

//客户端测试方法
public static void main(String[] args) throws Exception {
    Calculate add = new Add(); //加法运算器
    Calculate reduce = new Reduce(); //减法运算器
    System.out.println(add.count(2, 1)); //3.0
    System.out.println(reduce.count(2, 1)); //1.0
}

修改后的代码面试官应该是比较满意的，它具备了一定的面向对象思想，并且具有了一定的可扩展性，假如需要增加求平方运算，直接增加一个实现了Calculate接口的求平方的类即可，然后客户端使用多态调用，其它的业务类均不需要变化。

使用设计模式精益求精

上面的代码还有优化的空间，观察客户端测试方法，如果客户端想要使用一个加法运算器，它必须要构造加法运算器的对象才能使用里面的加法方法。也就是说，客户端代码和Calculate接口的所有实现类紧密耦合在一起，这样做的缺点是改一发而动全身，比如将来Add类的类名变成了AddAnother，那么客户端的实例化代码就需要改变，有人说改一下不就是很简单嘛？在本例中确实很简单，但实际情况更可能是有许多客户端代码调用Add类，你要把客户端代码统统改一下吗？你敢改吗？所以这就是耦合的弊端-改一发而动全身。使用简单工厂可以缓解这一问题：

class CalculateFactory {
    public static Calculate createCalculate(String mark) {
        Calculate calculate = null;
        switch (mark) {
        case "+":
            calculate = new Add(); // 加法运算器
            break;
        case "_":
            calculate = new Reduce(); // 减法运算器
            break;
        // 乘法和除法的两个运算器类的实例化以及default语句省略...
        }// end switch
        return calculate;
    }
}

// 客户端测试方法
public static void main(String[] args) throws Exception {
    Calculate add = CalculateFactory.createCalculate("+"); // 加法运算器
    Calculate reduce = CalculateFactory.createCalculate("-"); // 减法运算器
    System.out.println(add.count(2, 1)); // 3.0
    System.out.println(reduce.count(2, 1)); // 1.0
}

由以上代码，运算器类对象的创建工作全部交给CalculateFactory工厂类，客户端代码只和CalculateFactory工厂类耦合。如果Add类的类名发生变化，则只需要修改CalculateFactory这一个类即可，以前写好的客户端代码完全不动，这就是解耦带来的好处。这里有人可能会挑刺了，增加功能依然要修改之前的代码，这违背了开闭原则，没错，实际情况下，完全遵守开闭原则是很困难的，甚至是无法做到的事情，我们能做到的就是尽量遵守。

注：网上也流行一种在工厂类中使用反射来创建对象的写法，这种写法看似高大上，但是依然存在客户端代码和运算器类耦合的特点，所以个人不建议使用（仅代表个人观点）

限于本人水平问题，以上阐述可能不对，请在留言处批评指正，我们共同进步！

参考文献：《大话设计模式》程杰. 清华大学出版社