简单工厂模式 java示例

╰半夏微凉° 2022-07-25 15:35 133阅读 0赞

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

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

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

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

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

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

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

![Center][]

以下是实现代码：

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);  
  
\}  
\}

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

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

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

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

[Center]: /images/20220724/3221fa311f5c43fcb3b2840ea06747ef.png