工厂模式

标签: 简单工厂模式  抽象工厂模式  工厂方法模式

简介

  • 常见的实例化对象模式

  • 用工厂方法替代new操作的一种模式。

  • 当我们使用new操作实例化对象时,调用构造函数完成初始化。若初始化仅是进行赋值等简单的操作,写入构造函数即可。但如果初始化时需要执行一长串复杂的代码,将多个工作装入一个方法,是不妥的。

  • 创建实例与使用实例分离。将创建实例所需的大量初始化工作从基类的构造函数中分离出去。

  • 简单工厂模式、工厂方法模式针对的是一个产品等级结构;而抽象工厂模式针对的是多个产品等级结构

简单工厂模式

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

  • 角色

    • 基类接口:简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
    • 子类(实现类/产品类):简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。
    • 工厂类:产生实例。简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法(对工厂类实例化,调用方法)可以被外界直接调用,创建所需的产品对象。
  • 图解
    这里写图片描述

  • 实质

    • 根据传入工厂类成员方法(实例化函数)的参数,动态创建产品类实例。
  • 优点

    • 外界不必管内部究竟如何创建及组织对象的,仅仅需要负责“消费”对象即可。
  • 缺点

    • 由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中。
    • 它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。
    • 我们前面提到,工厂类根据传入方法的参数,动态创建产品类实例。当我们增加产品类时,工厂类方法需要增加参数,修改代码。
  • 应用场景

    • 工厂类负责创建的对象比较少;
    • 客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;
    • 由于简单工厂很容易违反高内聚责任分配原则,因此一般只在很简单的情况下应用。
  • 实例

查看实例https://blog.csdn.net/liang19890820/article/details/70652199

  • 编程语言分为好多种,三大流行语言为C++、Python、Java。

  • 基类:程序语言类,实现接口。

#ifndef _PARENT_H_
#define _PARENT_H_

#include<string>

using namespace std;

class Language {
public:
    virtual string name() = 0;
};

#endif // !_PARENT_H_
  • 子类:各种语言,具体实现。
#ifndef _CHILD_H_
#define _CHILD_H_

#include "parent.h"

class CPlusPlus : public Language {
public:
    string name() {
        string name = "C++";
        return name;
    }
};

class Java : public Language {
public:
    string name() {
        string name = "java";
        return name;
    }
};

class Python : public Language {
public:
    string name() {
        string name = "python";
        return name;
    }
};

#endif // !_CHILD_H_
  • 工厂类:实例化各个子类,创建实例。
#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "child.h"

class Factory {
public:
    Language* createLanguage(const int& flag) {
        Language *language = nullptr;
        switch (flag) {
        case 1:
            language = new CPlusPlus();
            break;
        case 2:
            language = new Java();
            break;
        case 3:
            language = new Python();
            break;
        }
        return language;
    }
};

#endif // !_FACTORY_H_
  • main函数
#include<iostream>
#include"factory.h"

using namespace std;

int main(int argc, char* argv[]) {
    Factory *factor = new Factory();  //实例化工厂
    //1:C++   2:java   3:python
    for (int i = 1; i < 4; ++i) {
        //工厂类成员方法动态决定对象的实例化
        Language *language = factor->createLanguage(i);  
        cout << language->name() << endl;
    }
    getchar();
    return 0;
}
  • 结果
    这里写图片描述

工厂方法模式

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,仅负责具体工厂子类必须实现的接口,这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

  • 实现“开—闭”原则,实现可扩展。

  • 角色

    • 抽象产品(基类):工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。
    • 具体产品(子类):实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应。
    • 抽象工厂:工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
    • 具体工厂:实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建产品对象。
  • 图解
    这里写图片描述

  • 应用场景

    • 单一产品,对简单工厂模式的改进。
  • 实例

查看实例https://blog.csdn.net/liang19890820/article/details/70652858

  • 计算机组件由CPU、显示屏、芯片组成。每个组件有对应的厂商。

  • 基类:计算机组件。

#ifndef _PARENT_H_
#define _PARENT_H_

#include<string>

using namespace std;

class  CM{
public:
    virtual string name() = 0;
};

#endif // !_PARENT_H_
  • 子类:各大组件。
#ifndef _CHILD_H_
#define _CHILD_H_

#include "parent.h"

class CPU : public CM {
public:
    string name() {
        string name = "CPU";
        return name;
    }
};

class Chip : public CM {
public:
    string name() {
        string name = "Chip";
        return name;
    }
};

class Display : public CM {
public:
    string name() {
        string name = "Display";
        return name;
    }
};

#endif // !_CHILD_H_
  • 抽象工厂:对具体工厂的抽象。
#ifndef _FACTORY_H_
#define _FACTORY_H_

#include "child.h"
#include "ConcreteFactory.h"

class AbstractFactory {
public:
    virtual CM* createCM() = 0;
};

#endif // !_FACTORY_H_
  • 具体工厂:生产各大组件。
#ifndef _CONCRETEFACTORY_H_
#define _CONCRETEFACTORY_H_

#include "child.h"
#include "factory.h"

class CPUFactory : public AbstractFactory{
public:
    CM* createCM() {
        return new CPU();
    }
};

class ChipFactory : public AbstractFactory {
public:
    CM* createCM() {
        return new Chip();
    }
};

class DisplayFactory : public AbstractFactory {
public:
    CM* createCM() {
        return new Display();
    }
};

#endif // !_CONCRETEFACTORY_H_
  • main函数
#include<iostream>
#include"ConcreteFactory.h"

using namespace std;

int main(int argc, char* argv[]) {

    AbstractFactory *factory = new CPUFactory();
    CM* cm = factory->createCM();
    cout << cm->name() << endl;

    factory = new ChipFactory();
    cm = factory->createCM();
    cout << cm->name() << endl;

    factory = new DisplayFactory();
    cm = factory->createCM();
    cout << cm->name() << endl;

    getchar();
    return 0;
}
  • 结果
    这里写图片描述

抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时,使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口,使客户端在不必指定产品的具体的情况下,创建多个产品族中的产品对象。

  • 简介

    • 当每个抽象产品都有多于一个的具体子类的时候,工厂角色怎么知道实例化哪一个子类呢?比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色,分别对应于这两个具体产品角色,每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
  • 图解
    这里写图片描述

  • 注意

    • 创建实例和使用实例分离:系统不依赖于产品类实例如何被创建,组合和表达的细节;
    • 系统的产品有多于一个的产品族,而系统只消费其中某一族的产品;
    • 同属于同一个产品族是在一起使用的。
    • 系统提供一个产品类的库,所有产品以同样的接口出现,从而使客户端不依赖于实现。
  • 优点

    • 分离了具体的类
    • 易于交换产品系列
    • 有利于产品的一致性
    • 不改变产品等级结构的情况下,增加产品族就是意味着向每一个产品等级结构中增加一个或者多个新的具体产品角色,这时只需要向工厂等级结构中增加新的元素就可以了。
  • 缺点

    • 难以支持新种类的产品。在产品族数目不变的情况下,增加产品等级结构,相当于增加一个与现有产品等级结构平行的一个新的产品等级结构,这时需要向修改所有的工厂角色,增加一个新的工厂方法,这是不支持OCP(开放—封闭原则)的。
  • 实例

查看实例https://blog.csdn.net/liang19890820/article/details/70653800

版权声明:本文为weixin_40087851原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_40087851/article/details/82079446

智能推荐

java乐观锁和悲观锁最底层的实现

1. CAS实现的乐观锁 CAS(Compare And Swap 比较并且替换)是乐观锁的一种实现方式,是一种轻量级锁,JUC 中很多工具类的实现就是基于 CAS 的,也可以理解为自旋锁 JUC是指import java.util.concurrent下面的包, 比如:import java.util.concurrent.atomic.AtomicInteger; 最终实现是汇编指令:lock...

Python 中各种imread函数的区别与联系

  原博客:https://blog.csdn.net/renelian1572/article/details/78761278 最近一直在用python做图像处理相关的东西,被各种imread函数搞得很头疼,因此今天决定将这些imread总结一下,以免以后因此犯些愚蠢的错误。如果你正好也对此感到困惑可以看下这篇总结。当然,要了解具体的细节,还是应该 read the fuc...

用栈判断一个字符串是否平衡

注: (1)本文定义:左符号:‘(’、‘[’、‘{’…… 右符号:‘)’、‘]’、‘}’……. (2)所谓的字符串的符号平衡,是指字符串中的左符号与右符号对应且相等,如字符串中的如‘(&r...

JAVA环境变量配置

位置 计算机->属性->高级系统设置->环境变量 方式一 用户变量新建path 系统变量新建classpath 方式二 系统变量 新建JAVA_HOME,值为JDK路径 编辑path,前加 方式三 用户变量新建JAVA_HOME 此路径含lib、bin、jre等文件夹。后运行tomcat,eclipse等需此变量,故最好设。 用户变量编辑Path,前加 系统可在任何路径识别jav...

常用的伪类选择器

CSS选择器众多 CSS选择器及权重计算 最常用的莫过于类选择器,其它的相对用的就不会那么多了,当然属性选择器和为类选择器用的也会比较多,这里我们就常用的伪类选择器来讲一讲。 什么是伪类选择器? CSS伪类是用来添加一些选择器的特殊效果。 常用的为类选择器 状态伪类 我们中最常见的为类选择器就是a标签(链接)上的为类选择器。 当我们使用它们的时候,需要遵循一定的顺序问题,否则将可能出现bug 注意...

猜你喜欢

ButterKnife的使用介绍及原理探究(六)

前面分析了ButterKnife的源码,了解其实现原理,那么就将原理运用于实践吧。 github地址:       点击打开链接 一、自定义注解 这里为了便于理解,只提供BindView注解。 二、添加注解处理器 添加ViewInjectProcessor注解处理器,看代码, 这里分别实现了init、getSupportedAnnotationTypes、g...

1.写一个程序,提示输入两个字符串,然后进行比较,输出较小的字符串。考试复习题库1|要求:只能使用单字符比较操作。

1.写一个程序,提示输入两个字符串,然后进行比较,输出较小的字符串。 要求只能使用单字符比较操作。 参考代码: 实验结果截图:...

小demo:slideDown()实现二级菜单栏下拉效果

效果如下,鼠标经过显示隐藏的二级菜单栏 但是这样的时候会存在一个问题,就是鼠标快速不停移入移出会导致二级菜单栏闪屏现象,一般需要使用stop()来清除事件  ...

基于docker环境的mysql主从复制

1、安装docker 可以参考之前的博客,之前写过了~ 2、拉取mysql镜像 3、创建mysql01和mysql02实例 主: 从: 4、进入容器修改配置 1)修改主数据库配置 进入主数据库容器 切换到 etc/mysql/目录下 查看可以看到my.cnf文件,使用vim编辑器打开,但是需要提前安装 安装vim命令: 安装成功后,修改my.cnf文件 新增配置后的my.cnf: binlog 日...

机器学习算法之决策树

原文:http://www.jianshu.com/p/6eecdeee5012 决策树是一种简单高效并且具有强解释性的模型,广泛应用于数据分析领域。其本质是一颗由多个判断节点组成的树,如: 决策树 在使用模型进行预测时,根据输入参数依次在各个判断节点进行判断游走,最后到叶子节点即为预测结果。 如何构造决策树 决策树算法的核心是通过对数据的学习,选定判断节点,构造一颗合适的决策树。 假设我们从用户...