简单工厂模式 java示例

声明：本博客里面设计模式相关的文章，均是学习 《大话设计模式》 的笔记。

简单工厂模式（simple factory pattern）：简单工厂模式属于创建型模式，也叫静态工厂模式，是由一个工厂对象来决定创建哪一种产品类的实例，通过定义一个类来负责创建其他类的实例，被创建的实例通常都有共同的父类。实质是由一个工厂类根据传入的参数，动态决定创建那一个产品类。

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

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

抽象产品角色：简单工厂模式所创建的所有对象的父类，负责描述所有实例公有的公共接口。

具体产品角色：简单工厂模式所创建的具体实例对象，这些对象往往都拥有共同的父类。

下面以运算器为例，如图是运算器结构的UML简图，

以下是实现代码：

package simple.factory;
public abstract class Operation {
double numberA=0d;
double numberB=0d;

protected void setNumberA(double number){
numberA = number;
}
protected double getNumberA(){
return numberA;
}

protected void setNumberB(double number){
numberB = number;
}
protected double getNumberB(){
return numberB;
}

public abstract double getResult();

}

package simple.factory;
public class OperationAdd extends Operation{
double result = 0d;

public double getResult(){
result = numberA+numberB;
return result;
}
}

package simple.factory;
public class OperationSubtraction extends Operation{
double result = 0d;

public double getResult(){
result = numberA-numberB;
return result;
}
}

package simple.factory;
public class OperationDivision extends Operation{
double result = 0d;

public double getResult(){
if(numberB !=0){
result = numberA/numberB;
}else{
System.out.println("Exception: divisor is zero!");
result = -0.0d;
}
return result;
}
}

package simple.factory;
public class OperationFactory {

public static Operation specificOperate(String operate){
Operation mOperation = null;
switch (operate){
case "+":{
mOperation = new OperationAdd();
break;
}
case "-":{
mOperation = new OperationSubtraction();
break;
}
case "*":{
mOperation = new OperationMultiplication();
break;
}
case "/":{
mOperation = new OperationDivision();
break;
}
default :{
break;
}
}
return mOperation;
}


}

package simple.factory;
import java.util.Scanner;
public class OperateResult {

@SuppressWarnings("resource")
public static void main(String args[]){
Scanner mScanner = new Scanner(System.in);
double operateResult =0d;

System.out.println("please input numberA:");
double firstNum = mScanner.nextDouble();

System.out.println("please input numberB:");
double secondNum = mScanner.nextDouble();

System.out.println("please input operate + - * /:");
String mOperate = mScanner.next();

Operation spesificOperate = OperationFactory.specificOperate(mOperate);
if(spesificOperate !=null){
spesificOperate.setNumberA(firstNum);
spesificOperate.setNumberB(secondNum);
operateResult = spesificOperate.getResult();
}

System.out.print("operate result is :");
System.out.println(operateResult);

}
}

简单工厂模式分析：解决的 问题是如何实例化一个合适的对象，核心思想就是有一个专门的类来负责创建实例的过程。

具体来说，把产品看成是一系列的类的集合，这些类是由某个抽象类或接口派生出的一个对象树，而工厂类用来产生一个合适的对象来满足客户的要求。

优点：工厂类是整个模式的核心，它包含必要的逻辑判断，能根据外界提供的信息，来决定究竟创建那个具体类的对象，用户使用时可以根据工厂类去创建所需的实例，而无需关心这些类是如何创建如何组织的，有利于整个软件体系结构的优化。

缺点：由于工厂类集中了所有实例的创建逻辑，这就导致一旦这个工厂出现问题，所有的客户端都会受牵连。由于简单工厂模式的产品是基于一个共同的抽象类或接口的，这样一来，当产品的种类增加时，即有不同的产品接口或抽象类的时候，工厂类就需要判断何时创建何种种类的产品，导致了混淆，违背了单一职责，让系统丧失了灵活性和可维护性。更重要的是，简单工厂模式违背了开放-封闭原则，就是违背了 系统对扩展开放，对修改关闭 的原则，因为增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。