最近读了《大话设计模式》一书，觉得里面讲解的简单工厂十分不错，在此加上自己的理解分享给大家。
一道简单的面试题
小菜去面试，面试题是“输入两个数字和一个运算符号，使用面向对象语言编写程序求出结果”。题目比较简单，小菜花了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这一个类即可，以前写好的客户端代码完全不动，这就是解耦带来的好处。这里有人可能会挑刺了，增加功能依然要修改之前的代码，这违背了开闭原则，没错，实际情况下，完全遵守开闭原则是很困难的，甚至是无法做到的事情，我们能做到的就是尽量遵守。
注：网上也流行一种在工厂类中使用反射来创建对象的写法，这种写法看似高大上，但是依然存在客户端代码和运算器类耦合的特点，所以个人不建议使用（仅代表个人观点）
限于本人水平问题，以上阐述可能不对，请在留言处批评指正，我们共同进步！
参考文献：《大话设计模式》程杰. 清华大学出版社
