设计模式之-----工厂方法模式

今天来学习工厂方法模式，这个工厂方法模式可以看做是简单工厂模式的升级版，但是在我学习的过程中发现，简单工厂模式与工厂方法模式虽然相似，但是，简单工厂模式却违反了设计模式六大原则的--开-闭原则，而工厂方法模式在一定程度上将新增的需求对于修改原来的代码的情况降低了许多。这也是工厂方法模式的优点之一。

工厂方法模式也有缺点，看完这个例子就会明白。

还是拿简单工厂模式的那个计算器的例子

先看包结构

这里要说明的是有两个接口，一个是工厂需要的，一个是具体某个操作工厂需要的，还是看示例会更明白。

package com.factorymethod.intf;

/**
 * 每个工厂要实现的接口
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public interface ICreateOperationFactory {
	
	public IOperationFactory createOperationFactory();
}

package com.factorymethod.intf;

/**
 * 每个具体的实现类要实现的接口
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public interface IOperationFactory {

	public double getResult(double numOne, double numTwo);
}

可能看到这里还是一头雾水，不要着急，先向下看

加法，具体操作类

package com.factorymethod.amp;

import com.factorymethod.intf.IOperationFactory;

/**
 * 加法的具体操作类
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public class AddOperation implements IOperationFactory{

	public double getResult(double numOne, double numTwo) {
		return numOne + numTwo;
	}

}

加法，生产加法具体操作的工厂类

package com.factorymethod.impl;

import com.factorymethod.amp.AddOperation;
import com.factorymethod.intf.ICreateOperationFactory;
import com.factorymethod.intf.IOperationFactory;

/**
 * 加法工厂，返回具体的加法操作类
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public class AddFactory implements ICreateOperationFactory{

	public IOperationFactory createOperationFactory() {
		return new AddOperation();
	}

}

然后是测试类

package com.factorymethod.main;

import com.factorymethod.impl.AddFactory;
import com.factorymethod.intf.ICreateOperationFactory;
import com.factorymethod.intf.IOperationFactory;

public class TestMain {

	public static void main(String[] args) {
		ICreateOperationFactory iCreateOperationFactory = new AddFactory();
		IOperationFactory iOperationFactory = iCreateOperationFactory.createOperationFactory();
		double result = iOperationFactory.getResult(1, 1);
		System.out.println(result);
	}

}

这样一个工厂方法模式就完成了，你可能还是看不出它有什么好处，那么现在新的需求来了，我们要在增加一个减法的操作，如果这是简单工厂模式，你会怎么做？你肯定会在工厂实现方法里增加一个case分支，然后去判断，可是这样不就违背了开-闭原则了么？只对扩展开放，对修改关闭。但是现在的工厂方法模式就可以很好的实现这一个原则。

我们只需在原来的包中新建两个类

减法的具体操作类

代码如下

package com.factorymethod.amp;

import com.factorymethod.intf.IOperationFactory;

/**
 * 减法的具体操作类
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public class SubOperation implements IOperationFactory{

	public double getResult(double numOne, double numTwo) {
		return numOne - numTwo;
	}
}

还有生产减法具体操作类的减法工厂

package com.factorymethod.impl;

import com.factorymethod.amp.SubOperation;
import com.factorymethod.intf.ICreateOperationFactory;
import com.factorymethod.intf.IOperationFactory;

/**
 * 减法工厂，返回具体的减法操作类
 * @author ZHENGWEI
 * @date Jul 22, 2015
 */
public class SubFactory implements ICreateOperationFactory{

	public IOperationFactory createOperationFactory() {
		return new SubOperation();
	}

}

在调用的时候，只需要把加法的那个加法工厂变成减法工厂，剩下的都一样。是不是遵循了开-闭原则呢？