Java设计模式之简单工厂模式

目录

一、何为 简单工厂模式？

二、如何实现简单工厂模式？

三、Java 实现简单工厂模式

四、简单工厂模式优缺点？

五、简单工厂模式改进版 → 工厂模式

---

一、何为 简单工厂模式？

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。

二、如何实现简单工厂模式？

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

该模式中包含的角色及其职责：

• 工厂（Creator）角色

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

• 抽象产品（Product）角色

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

• 具体产品（Concrete Product）角色

是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

三、Java 实现简单工厂模式

接下来举一个栗子： 用面向对象的思想实现一个简单的计算器。

第一步：抽象产品（Product）角色入场

在这个栗子中，我们把计算器的所有运算操作抽象为Operation，每个功能（+ 、- 、* 、/）由具体的执行操作performOperation（）方法实现，这是行为抽象，采取接口实现，创建Operation接口，performOperation（）方法采取多参数传入，代码如下：

public interface Operation {
	//执行操作
	void performOperation(double... nums);

}

第二步：具体产品（Concrete Product）角色入场

接口抽象好了接下来便实现具体的实现类

加法

public class AddOperation implements Operation{
	@Override
	public void performOperation(double... nums){
		int numResult = 0;
		StringBuffer sb = new StringBuffer();
		for(int i = 0; i < nums.length; i ++) {
			numResult += nums[i];
			if(i == nums.length-1) {
				sb.append(nums[i]);
			}else {
				if(nums[i] < 0) {
					sb.append("("+nums[i]+")").append(" + ");
				}else
					sb.append(nums[i]).append(" + ");
			}	
		}
		System.out.println(sb + "="+numResult);
	}
}

减法

public class SubOperation implements Operation {

	@Override
	public void performOperation(double... nums) {
		double numResult = nums[0];
		StringBuffer sb = new StringBuffer(String.valueOf(nums[0]));
		for (int i = 1; i < nums.length; i++) {
			numResult -= nums[i];

			if(nums[i] < 0) {
				sb.append(" - ").append("("+nums[i]+")");
			}else
				sb.append(" - ").append(nums[i]);
		}
		System.out.println(sb + "=" + numResult);
	}
}

乘法

public class MulOperation implements Operation {

	@Override
	public void performOperation(double... nums) {
		double numResult = nums[0];
		StringBuffer sb = new StringBuffer(String.valueOf(nums[0]));
		for (int i = 1; i < nums.length; i++) {
			numResult *= nums[i];
			if(nums[i] < 0) {
				sb.append(" * ").append("("+nums[i]+")");
			}else
				sb.append(" * ").append(nums[i]);
		}
		System.out.println(sb + "=" + numResult);
	}
}

除法  （要注意除数不能为 0）

public class DivOperation implements Operation {
	@Override
	public void performOperation(double... nums) {
		double numResult = nums[0];
		StringBuffer sb = new StringBuffer(String.valueOf(nums[0]));
		if(numResult != 0) {
			for (int i = 1; i < nums.length; i++) {
				if (nums[i] == 0) {
					System.out.println("除数不能为 0 ！");
					break;
				}
				numResult /= nums[i];
				if(nums[i] < 0) {
					sb.append(" / ").append("("+nums[i]+")");
				}else
					sb.append(" / ").append(nums[i]);
				if(i == nums.length - 1) {
					System.out.println(sb + "=" + numResult);
				}
			}
		}else {//第一个数为0，结果为0
			for (int i = 1; i < nums.length; i++) {
				if(nums[i] < 0) {
					sb.append(" / ").append("("+nums[i]+")");
				}else
					sb.append("/").append(nums[i]);
			}
			System.out.println(sb + "=" + numResult);
		}
	}
}

第三步：有请工厂（Creator）角色入场

现在具体的加减乘除都实现好了，就缺一个专门的工厂类负责创建产品对象，从而调用产品类里的方法来实现具体的功能了

前面说到 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的实例。我在这里用了 switch 语句实现，也可以通过 if 语句判断或者 通过反射来实现。

public class OperationFactory {
	public static Operation createFactory(String s) {
		Operation operation = null;
		switch (s) {
			case "+":
				operation = new AddOperation();
				break;
			case "-":
				operation = new SubOperation();
				break;
			case "*":
				operation = new MulOperation();
				break;
			case "/":
				operation = new DivOperation();
				break;
		}
		return operation;
	}
}

第四步：创建测试类，测试我们的计算器有没有bug：

public class Test {
	public static void main(String[] args) {
		
		Operation operation1 = OperationFactory.createFactory("+");
		operation1.performOperation(1,-2,3);
		
		Operation operation2 = OperationFactory.createFactory("-");
		operation2.performOperation(4,5,-1);
		
		Operation operation3 = OperationFactory.createFactory("*");
		operation3.performOperation(1,2,-3);
		
		Operation operation4 = OperationFactory.createFactory("/");
		operation4.performOperation(3,3,-5);
	}
}

结果：

1.0 + (-2.0) + 3.0=2
4.0 - 5.0 - (-1.0)=0.0
1.0 * 2.0 * (-3.0)=-6.0
3.0 / 3.0 / (-5.0)=-0.2

计算正确！ ok，一个简单的计算器完成了！！！

四、简单工厂模式优缺点？

• 优点

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

• 缺点

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。不满足开闭原则！

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

五、简单工厂模式改进版 → 工厂模式

biu ~ 传送门