简单工厂模式是类的创建模式,又叫做静态工厂方法(Static Factory Method)模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

  简单工厂就是将多个if,else...代码块拆开,增加代码的可阅读性、便于后期的维护。一个接口,几个实现接口的类,再通过传参的形式在工厂类中根据类型去创建相应的具体类。

其结构如下图:

1.  最常见的简单工厂

  以最简单的加减乘除运算为例,建立一个通用的运算接口,其有两个抽象方法:一个是描述运算类型,另一个是具体的运算。UML类图如下:

对应的代码如下:

package cn.qlq;

public interface Operation {

    String operateType();

    Number operate(Number... nums);
}
package cn.qlq;

public class OperationAdd implements Operation {

    @Override
public String operateType() {
return "OperationAdd";
} @Override
public Number operate(Number... nums) {
Number result = 0;
for (Number number : nums) {
result = result.doubleValue() + number.doubleValue();
} return result;
} }
package cn.qlq;

public class OperationSub implements Operation {

    @Override
public String operateType() {
return "OperationSub";
} @Override
public Number operate(Number... nums) {
Number result = nums[0];
for (int i = 0, length_1 = nums.length; i < length_1; i++) {
if (i == 0) {
continue;
}
result = result.doubleValue() - nums[i].doubleValue();
} return result;
} }
package cn.qlq;

public class OperationMul implements Operation {

    @Override
public String operateType() {
return "OperationMul";
} @Override
public Number operate(Number... nums) {
Number result = nums[0];
for (int i = 0, length_1 = nums.length; i < length_1; i++) {
if (i == 0) {
continue;
}
result = result.doubleValue() * nums[i].doubleValue();
} return result;
} }
package cn.qlq;

public class OperationDiv implements Operation {

    @Override
public String operateType() {
return "OperationDiv";
} @Override
public Number operate(Number... nums) {
Number result = nums[0];
for (int i = 0, length_1 = nums.length; i < length_1; i++) {
if (i == 0) {
continue;
}
result = result.doubleValue() / nums[i].doubleValue();
} return result;
} }

工厂类:根据运算类型创建不同的对象,遇到不合法的运算抛出一个运行时异常。

package cn.qlq;

public class OperationFactory {

    public static Operation generateOperation(String type) {
Operation operation = null;
switch (type) {
case "OperationAdd":
operation = new OperationAdd();
break;
case "OperationSub":
operation = new OperationSub();
break;
case "OperationMul":
operation = new OperationMul();
break;
case "OperationDiv":
operation = new OperationDiv();
break;
default:
break;
} if (operation == null) {
throw new RuntimeException("不合法的运算类型");
} return operation;
}
}

测试代码:

package cn.qlq;

public class MainClass {

    public static void main(String[] args) {
String operationType = "OperationDiv";
Operation operation = OperationFactory.generateOperation(operationType);
if (operation == null) {
System.out.println("未知类型");
return;
} System.out.println(operation.operateType());
Number operate = operation.operate(1, 2);
System.out.println(operate);
} }

现在假设我们不用简单工厂模式,伪代码如下:

package cn.qlq;

public class MainClass {

    public static void main(String[] args) {
String operationType = "OperationDiv";
if ("OperationDiv".equals(operationType)) {
// 处理加法 } else if ("OperationSub".equals(operationType)) {
// 处理减法 } else if ("OperationMul".equals(operationType)) {
// 处理乘法 } else if ("OperationDiv".equals(operationType)) {
// 处理除法 } else {
throw new RuntimeException("error type");
}
} }

  上面代码确实看着比较繁琐,而且不易扩展。

  将来如果我们增加一种求平方根的运算,需要在增加一个else if ... 代码块,并且在该代码块中增加处理平方根的代码块。而如果使用了上面的简单工厂模式的话需要增加一个具体的实现类,并且在工厂类中增加1个 case "OperationSquare"... 代码块。

优点:

 该模式的核心是工厂类。工厂类中含有必要的逻辑判断,调用者不需要关注创建对象的部分,去除了与具体产品的依赖。简单工厂模式通过这种做法实现了对责任的分割,当系统引入新的运算的时候无需修改调用者。

缺点:

如果需要在方法里写很多与对象创建有关的业务代码,而且需要的创建的对象还不少的话,我们要在这个简单工厂类里编写很多个方法,每个方法里都得写很多相应的业务代码,而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高,而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。

2.  利用反射改造工厂-去掉工厂类中的分支判断(重要)

  对上面的简单工厂模式做一个简单的改造:新增一抽象类实现上面的接口,具体的运算类继承抽象类,并重写抽象类的抽象方法。

  这么做的好处是可以做到更好的封装,做一些前处理,验证参数等参数,当然也可以在抽象类中做一些后处理等操作。而且采用反射与约定的命名规则创建对象,增加一个新的运算规则的时候不需要改动工厂类(利用反射避免工厂类中分支判断的问题)。

改造如下:

(1)接口仍然采用上面的接口

(2)封装一个抽象类实现上面接口并重写其operate方法,在该方法中先验证参数,验证通过之后进行doOperate操作(一个抽象方法)

(3)具体的实现类继承上面抽象类,并且重写doOperate方法。

(4)工程类中采用反射创建具体的对象。

类图如下:

抽象类代码:

package cn.qlq;

public abstract class AbstractOperation implements Operation {

    @Override
public Number operate(Number... nums) {
if (nums == null || nums.length == 0) {
System.out.println("非法参数");
return 0;
} System.out.println("参数验证通过");
return doOperate(nums);
} public abstract Number doOperate(Number[] nums);
}

以加法操作为例继承上面抽象类,重写doOperate方法即可。其他减乘除类似。

package cn.qlq;

public class OperationAdd extends AbstractOperation {

    @Override
public String operateType() {
return "OperationAdd";
} @Override
public Number doOperate(Number... nums) {
Number result = 0;
for (Number number : nums) {
result = result.doubleValue() + number.doubleValue();
} return result;
} }

工厂类:(根据类型反射创建具体的类)

  这里需要遵循一个约定:运算的类型与对应运算实现类的类名完全一致才可以进行反射创建对象。当然可以根据其他规则进行转换。

package cn.qlq;

public class OperationFactory {

    public static Operation generateOperation(String type) {
String packageName = "cn.qlq.";
String className = packageName + type; // 反射创建对应的对象
Operation operation = null;
try {
Class clazz = Class.forName(className);
operation = (Operation) clazz.newInstance();
} catch (Exception e) {
// 此处应该记录日志
throw new RuntimeException("非法参数异常");
} return operation;
}
}

总结:

  简单工厂模式是由一个工厂类根据不同的参数类型创建出哪一种产品类的实例。

  工作中也是通过反射 + 简单工厂来使用的。一般将类型存在数据库中,客户端(浏览器)访问后台操作的时候根据数据库中的类型,通过简单工厂获取到对应的实例进行相应的操作。

简单工厂(SimpleFactory)模式的更多相关文章

  1. factory工厂模式之简单工厂SimpleFactory

    简单工厂(Simple Factory) 又叫静态工厂,是工厂模式三中状态中结构最为简单的.1.主要有一个静态方法,用来接受参数,并根据参数来决定返回实现同一接口的不同类的实例.2.或者针对每个产品, ...

  2. 设计模式之工厂方法模式VS简单工厂方法模式

    名词解释: 简单工厂:这个实在是没什么解释的,就是一个工厂类,然后有一个方法,根据传递的参数可以通过switch(你也可以是if,或者是使用高端的反射 )来进行对象的创建. 工厂方法:定义一个用于创建 ...

  3. 设计模式--简单工厂(Factory)模式

    温故而知新,看了以前写的博文<Asp.net读取Excel文件 2>http://www.cnblogs.com/insus/archive/2011/05/05/2037808.html ...

  4. 设计模式之简单工厂SimpleFactory的实现(配置文件)

    <?xml version="1.0" encoding="utf-8" ?> <configuration> <appSetti ...

  5. 设计模式之简单工厂SimpleFactory的实现

    internal interface Chart { void Display(); } internal class LineChart : Chart { public LineChart() { ...

  6. .Net简单工厂模式,工厂模式,抽象工厂模式实例

    1.定义   简单工厂模式:是由一个工厂对象决定创建出哪一种产品类的实例.简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现. 工厂模式:定义一个用于创建对象的接口, ...

  7. iOS常用设计模式——工厂方法(简单工厂模式,工厂方法模式, 抽象工厂模式)

    1. 简单工厂模式 如何理解简单工厂,工厂方法, 抽象工厂三种设计模式? 简单工厂方法包含:父类拥有共同基础接口,具体子类实现子类特殊功能,工厂类根据参数区分创建不同子类实例.该场景对应的UML图如下 ...

  8. C#设计模式-2工厂方法模式(Factory Method)

    什么是工厂模式?类比生活中的概念,当我们需要打电话的时候,我们需要一部手机,我们通常会选择直接去卖手机的实体店买.但在程序设计中,当我们需要调用一个类(PhoneA或PhoneB)的方法的时候,我们往 ...

  9. 设计模式(三)工厂方法模式(Factory Pattern)

    一.引言 在简单工厂模式中讲到简单工厂模式的缺点,有一点是——简单工厂模式系统难以扩展,一旦添加新产品就不得不修改简单工厂方法,这样就会造成简单工厂的实现逻辑过于复杂,然而本专题介绍的工厂方法模式可以 ...

随机推荐

  1. vue中的scoped分析以及在element-UI和vux中的应用

    vue使用了单文件组件方式来解耦视图即.vue后缀文件名 单文件组件组成部分: <template> </template> <script> </scrip ...

  2. JavaScript语法-流程控制语句

    一.JavaScript特殊语法 JS特殊语法: 1. 语句以;结尾,如果一行只有一条语句则 ;可以省略 (不建议) 2. 变量的定义使用var关键字,也可以不使用 * 用: 定义的变量是局部变量 * ...

  3. JavaScript map reduce

    23333333333333 map var s = []; for(let i=0;i<10;i++){ s.push(i); } function pow(x){ return x*x; } ...

  4. 这个中秋,我用 Java 画了一个月饼!

    栈长代表微信公众号 "Java技术栈" 祝所有粉丝中秋佳节快乐! 为了用一种特殊的方式表达我的心意,去年中秋节,我写了这篇文章: 为了写中秋这篇文章,我学了 20 种编程语言! 没 ...

  5. GlusterFS 安装

    一.简介 GlusterFS 是近年兴起的一个高性能开源分布式文件系统,其目标是全局命名空间.分布式前端的高性能文件系统,目前已被 RedHat 看中,GlusterFS 具有高扩展.高可性.高性能. ...

  6. DELPHI开始支持LINUX DOCKER

    DELPHI开始支持LINUX DOCKER 本方翻译自Marco Cantu的文章. 在过去的几年中,将服务器端解决方案(实际上是任何类型的应用程序)部署到轻量级容器而不是物理机器或虚拟机已经变得越 ...

  7. Chrome调试工具Developer Tools——前端必备神器

    本文链接:https://blog.csdn.net/u012542647/article/details/79401485 今天要给大家介绍一个神器,就是谷歌浏览器(Chorme)自带的前端调试工具 ...

  8. Win10登陆界面卡住,进去后无法打开网络相关的设置,谷歌浏览器无法上网

    今天Win10抽风,进入登录页面输入用户名和密码之后,大约过了10分钟才进入桌面.重启后仍然如此. 经过调查,问题主要出在网络相关模块上,网络无法正常初始化,导致登录一直卡在网络初始化上. 解决方法如 ...

  9. js---if判断的几种写法

    在写JS中最常见的就是 if 判断,但是直接写 if(){}else{}; 太low ,下面是常见的几种js的if判断的写法: /** * js 判断的几种写法 */ var a = 10,b = 2 ...

  10. Spring Cloud(一)简单的微服务集成Eureka

    1        Spring Cloud简介 1.1             简介 Spring Cloud项目的官方网址:https://projects.spring.io/spring-clo ...