前面我们讲了三个工厂模式,都是万变不离其宗,利用工厂模式来实例化不同的对象,虽然可能会多写一些代码,但这会为程序系统带来更方便的扩展性和尽量小的修改。
我们来从头回顾一下为什么要用工厂模式,实现一个计算器的程序,初级程序员可能立马分分钟就能写出代码来,例如:
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 @Override
15 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 args
13 */
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 @Override
15 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 args
13 */
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的反射机制。