首页 > 代码库 > 工厂模式——结语
工厂模式——结语
前面我们讲了三个工厂模式，都是万变不离其宗，利用工厂模式来实例化不同的对象，虽然可能会多写一些代码，但这会为程序系统带来更方便的扩展性和尽量小的修改。
我们来从头回顾一下为什么要用工厂模式，实现一个计算器的程序，初级程序员可能立马分分钟就能写出代码来，例如：
1 package day_4_summary; 2 3 /** 4 * 计算器 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public class Calc {10 public static void main(String[] args){11 double numA = 1;12 double numB = 2;13 String opt = "+";14 double result = 0;15 16 if (opt.equals("+")){17 result = numA + numB;18 }19 if (opt.equals("-")){20 result = numA - numB;21 }22 if (opt.equals("*")){23 result = numA * numB;24 }25 if (opt.equals("/")){26 result = numA / numB; //我们这里暂不考虑除数为0的情况27 }28 29 System.out.println("result=" + result);30 }31 }
几乎是20行的代码就实现了需求，但“合适”不呢？这种写法，是初学编程时C语言面向过程的编程方式，这种方式可能会伴随我们很久很久，就算学到了面向对象语言，这种思维方式也会很久很久挥之不去。4个if，要做4次判断，有人说那我用else if，我用switch不就可以了吗？
面向对象编程不是用一门面向对象的语言来编程。
面向对象编程，让我们可维护、可复用、可扩展，低耦合、高内聚，这些到底是什么呢？我们用面向对象的编程方法来实现这个计算器，并且使用用简单工厂模式。
我们首先画出简单工厂模式的UML类图，把加减乘除抽象成一个运算类，这里就能做到了可复用，如果还有开方、乘方运算再实现运算类就可以了，这就是可扩展。
抽象运算类：
1 package day_4_summary; 2 3 /** 4 * 抽象运算类 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public abstract class AbstractOption {10 private double numA;11 private double numB;12 public double getNumA() {13 return numA;14 }15 public void setNumA(double numA) {16 this.numA = numA;17 }18 public double getNumB() {19 return numB;20 }21 public void setNumB(double numB) {22 this.numB = numB;23 }24 25 public abstract double getResult();26 }
实现抽象运算类，只举加法：
1 package day_4_summary; 2 3 /** 4 * 加法类 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public class OptionAdd extends AbstractOption {10 11 /* (non-Javadoc)12 * @see day_4_summary.AbstractOption#getResult()13 */14 @Override15 public double getResult() {16 17 return super.getNumA() + super.getNumB();18 }19 20 }
工厂类，用来负责实例化具体对象：
package day_4_summary;/** * 工厂类 * @author turbo * * 2016年9月7日 */public class OptionFactory { public static AbstractOption CreateOption(String opt){ AbstractOption option = null; switch (opt) { case "+" : option = new OptionAdd(); break; case "-" : //创建减法运算符类 break; case "*" : //创建乘法运算类 break; case "/" : //创建除法运算类 break; default : break; } return option; }}
客户端：
1 package day_4_summary; 2 3 /** 4 * 客户端 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public class Main {10 11 /**12 * @param args13 */14 public static void main(String[] args) {15 AbstractOption option = OptionFactory.CreateOption("+");16 double result = 0.0;17 option.setNumA(1);18 option.setNumB(2);19 result = option.getResult();20 }21 22 }
这样我们就用简单工厂模式实现了一个计算器，比起面向过程的编程方式，这样是不是有点感觉了呢？我们想要加法，只需将“+”传递给工厂类让它帮我们实例化一个加法运算类即可，我们不用管它是如何实现的。其他人想用加法时，只需调用这个工厂类来实例化即可，我们把工厂类的接口提供给他，他不用去管是怎么实现的，他只管用，这不就是可复用吗？
如果，我要增加一个开方运算，你要实现一个更复杂的运算，那我们俩都要同时去修改工厂类里的代码，这将使得代码的维护性变得很差，能不能提供给我们一个接口，让我们自己去实现我们想要做的运算呢？这个时候就得用工厂方法模式了。
同样，我们首先画出UML类图：
应该能明白了吧？如果要新增一个运算方式，我们只需实现操作类和实现工厂类即可，而不必在原有代码的基础上做修改。
抽象运算类和加法类不变，还是和上面的代码一样，我们主要来看工厂类的变化，此时工厂类变成了一个接口。
1 package day_4_summary; 2 3 /** 4 * 工厂接口类 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public interface IFactory {10 AbstractOption createOption();11 }
接着实现加法工厂类，省去其他运算工厂类。
1 package day_4_summary; 2 3 /** 4 * 加法工厂类 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public class OperationAddFactory implements IFactory {10 11 /* (non-Javadoc)12 * @see day_4_summary.IFactory#createOption()13 */14 @Override15 public AbstractOption createOption() {16 17 return new OptionAdd();18 }19 20 }
客户端代码：
1 package day_4_summary; 2 3 /** 4 * 客户端 5 * @author turbo 6 * 7 * 2016年9月7日 8 */ 9 public class Main {10 11 /**12 * @param args13 */14 public static void main(String[] args) {15 IFactory factory = new OperationAddFactory();16 AbstractOption option = factory.createOption();17 double result = 0.0;18 option.setNumA(1);19 option.setNumB(1);20 result = option.getResult();21 System.out.println(result);22 }23 24 }
这两者主要的区别就是上面说的，如果要新增一个运算类，简单工厂模式我得要在原有代码基础上修改，如果是工厂方法模式，我只需再实现工厂接口类即可，而不用再原有代码上做修改。
至于抽象工厂方法，上一篇说的比较详细，这里主要是对比简单工厂模式和工厂方法模式，掌握了工厂方法模式后，即会抽象工厂模式。在抽象工厂模式中利用反射机制，这个值得研究一下。在后续会仔细研究一下Java的反射机制。
工厂模式——结语