设计模式(8)-工厂模式(Factory)

最新推荐文章于 2024-05-05 15:22:22 发布
最新推荐文章于 2024-05-05 15:22:22 发布
阅读量4.4k 收藏 3
点赞数 2
分类专栏： Qt 设计模式(Qt版)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tandesir/article/details/8492538
版权

【描述】工厂模式有3种类型：简单工厂，工厂方法，抽象工厂。这3种设计模式都属于创建型的设计模式。简单工厂的工厂是具象的，没有抽象的工厂类。工厂方法，定义了一个创建对象的接口，让子类来决定具体实例化哪一个类。抽象工厂模式面对的问题是多产品等级结构的系统设计。相对于简单工厂，工厂方法和抽象工厂都定义了抽象的工厂类。工厂方法与抽象工厂的区别在于：工厂方法的“工厂”只制造单一的“产品”，而抽象工厂可以制造一族“产品”。

1 简单工厂（Simple Factory）

【UML图】

图1 简单工厂

1 定义了一个具象的工厂Factory；

2 定义了一个抽象的产品Product以及两个具象的产品ProductA，ProductB，实现了产品的方法operation；

3 Factory将根据需要选择制造具象的产品。(注意是具象的产品，策略模式以及建造模式Client调用的是抽象的接口，这是工厂模式与策略模式、建造模式关键区别，下同)

 

【代码清单】

common.h

#ifndef COMMON_H
#define COMMON_H

enum {Product_A = 0, Product_B = 1};

#endif // COMMON_H

product.h

#ifndef PRODUCT_H
#define PRODUCT_H

class Product
{
public:
    Product();

public:
    virtual void operation();
};

#endif // PRODUCT_H


producta.h

#ifndef PRODUCTA_H
#define PRODUCTA_H

#include "product.h"

class ProductA : public Product
{
public:
    ProductA();

public:
    void operation();
};

#endif // PRODUCTA_H


productb.h

#ifndef PRODUCTB_H
#define PRODUCTB_H

#include "product.h"

class ProductB : public Product
{
public:
    ProductB();

public:
    void operation();
};

#endif // PRODUCTB_H


simplefactory.h

#ifndef SIMPLEFACTORY_H
#define SIMPLEFACTORY_H

#include "product.h"

class SimpleFactory
{
public:
    SimpleFactory();

public:
    Product* createProduct(int type);
};

#endif // SIMPLEFACTORY_H


product.cpp

#include <QDebug>
#include "product.h"

Product::Product()
{
    qDebug()<<"construct Product";
}

void Product::operation()
{
    qDebug()<<"Product operation";
}


producta.cpp

#include <QDebug>
#include "producta.h"

ProductA::ProductA()
{
    qDebug()<<"construct ProductA";
}

void ProductA::operation()
{
    qDebug()<<"ProductA::operation";
}


productb.cpp

#include <QDebug>
#include "productb.h"

ProductB::ProductB()
{
    qDebug()<<"construct ProductB";
}

void ProductB::operation()
{
    qDebug()<<"ProductA::operation";
}


simplefactory.cpp

#include <QDebug>
#include "common.h"
#include "simplefactory.h"
#include "producta.h"
#include "productb.h"

SimpleFactory::SimpleFactory()
{
}

Product* SimpleFactory::createProduct(int type)
{
    Product *p = NULL;

    switch(type)
    {
    case Product_A:
        p = new ProductA;
        break;
    case Product_B:
        p = new ProductB;
        break;
    default:;
    }

    return p;
}

 

main.cpp

#include "simplefactory.h"
#include "product.h"
#include "common.h"

int main(int argc, char **argv)
{
    SimpleFactory *factory = new SimpleFactory;
    Product * product = factory->createProduct(Product_A);
    product->operation();

    return 0;
}


【运行结果】

construct Product 
construct ProductA 
ProductA::operation


2 工厂方法(Factory Method)

【UML图】

图2 工厂方法

1 定义了一个抽象的工厂Factory以及两个具象的工厂，实现了产品制造的方法createProduct()；

2 定义了一个抽象的产品Product以及两个具象的产品ProductA，ProductB，实现了产品的方法operation；

3 Factory将根据需要选择制造具象的产品。

【代码清单】

factory.h

#ifndef FACTORY_H
#define FACTORY_H

#include "product.h"

class Factory
{
public:
    Factory();

public:
    virtual Product *createProduct();
};

#endif // FACTORY_H


factorya.h

#ifndef FACTORYA_H
#define FACTORYA_H

#include "factory.h"
#include "producta.h"

class FactoryA : public Factory
{
public:
    FactoryA();

public:
    ProductA *createProduct();
};

#endif // FACTORYA_H


factoryb.h

#ifndef FACTORYB_H
#define FACTORYB_H

#include "factory.h"
#include "productb.h"

class FactoryB : public Factory
{
public:
    FactoryB();

public:
    ProductB *createProduct();
};

#endif // FACTORYB_H


product.h

#ifndef PRODUCT_H
#define PRODUCT_H

class Product
{
public:
    Product();

public:
    virtual void operation();
};

#endif // PRODUCT_H


producta.h

#ifndef PRODUCTA_H
#define PRODUCTA_H

#include "product.h"

class ProductA : public Product
{
public:
    ProductA();

public:
    void operation();
};

#endif // PRODUCTA_H


productb.h

#ifndef PRODUCTB_H
#define PRODUCTB_H

#include "product.h"

class ProductB : public Product
{
public:
    ProductB();

public:
    void operation();
};

#endif // PRODUCTB_H


factory.cpp

#include <QDebug>
#include "factory.h"

Factory::Factory()
{
    qDebug()<<"construct Factory";
}

Product *Factory::createProduct()
{
    return new Product;
}


factorya.cpp

#include <QDebug>
#include "factorya.h"

FactoryA::FactoryA()
{
     qDebug()<<"construct FactoryA";
}

ProductA *FactoryA::createProduct()
{
    return new ProductA;
}


factoryb.cpp

#include <QDebug>
#include "factoryb.h"


FactoryB::FactoryB()
{
     qDebug()<<"construct FactoryB";
}

ProductB* FactoryB::createProduct()
{
    return new ProductB;
}


product.cpp

#include <QDebug>
#include "product.h"

Product::Product()
{
    qDebug()<<"construct Product";
}

void Product::operation()
{
    qDebug()<<"Product Operation";
}


producta.cpp

#include <QDebug>
#include "producta.h"

ProductA::ProductA()
{
    qDebug()<<"construct ProductA";
}

void ProductA::operation()
{
    qDebug()<<"ProductA operation";
}


productb.cpp

#include <QDebug>
#include "productb.h"

ProductB::ProductB()
{
    qDebug()<<"construct ProductB";
}

void ProductB::operation()
{
    qDebug()<<"ProductB operation";
}


main.cpp

#include "factory.h"
#include "factorya.h"
#include "factoryb.h"
#include "product.h"

int main(int argc, char **argv)
{
    Factory *factory = new FactoryA;
    Product *product = factory->createProduct();
    product->operation();

    return 0;
}


【运行结果】

construct Factory 
construct FactoryA 
construct Product 
construct ProductA 
ProductA operation


3 抽象工厂(Abstract Factory)

【UML图】

图3 抽象工厂

1 定义了一个抽象的工厂Factory以及两个具象的工厂，实现了产品制造的方法createProductA()，createProductB；

2 定义了一个抽象的产品Product以及两个具象的产品ProductA，ProductB，实现了产品的方法operationA，operationB；

3 Factory将根据需要选择制造一族具象的产品。

 

【代码清单】

factory.h

#ifndef FACTORY_H
#define FACTORY_H

#include "product.h"

class Factory
{
public:
    Factory();

public:
    virtual Product *createProductA();
    virtual Product *createProductB();
};

#endif // FACTORY_H


factorya.h

#ifndef FACTORYA_H
#define FACTORYA_H

#include "factory.h"
#include "producta.h"
#include "productb.h"

class FactoryA : public Factory
{
public:
    FactoryA();

public:
    ProductA *createProductA();
    ProductB *createProductB();
};

#endif // FACTORYA_H


factoryb.h

#ifndef FACTORYB_H
#define FACTORYB_H

#include "factory.h"
#include "producta.h"
#include "productb.h"

class FactoryB : public Factory
{
public:
    FactoryB();

public:
    ProductA *createProductA();
    ProductB *createProductB();
};

#endif // FACTORYB_H


product.h

#ifndef PRODUCT_H
#define PRODUCT_H

class Product
{
public:
    Product();

public:
    virtual void operationA();
    virtual void operationB();
};

#endif // PRODUCT_H


producta.h

#ifndef PRODUCTA_H
#define PRODUCTA_H

#include "product.h"

class ProductA : public Product
{
public:
    ProductA();

public:
    void operationA();
};

#endif // PRODUCTA_H


productb.h

#ifndef PRODUCTB_H
#define PRODUCTB_H

#include "product.h"

class ProductB : public Product
{
public:
    ProductB();

public:
    void operationB();
};

#endif // PRODUCTB_H

 

factory.cpp

#include <QDebug>
#include "factory.h"

Factory::Factory()
{
    qDebug()<<"construct Factory";
}

Product *Factory::createProductA()
{
    return new Product;
}

Product *Factory::createProductB()
{
    return new Product;
}


factorya.cpp

#include <QDebug>
#include "factorya.h"

FactoryA::FactoryA()
{
     qDebug()<<"construct FactoryA";
}

ProductA *FactoryA::createProductA()
{
    return new ProductA;
}

ProductB *FactoryA::createProductB()
{
    return new ProductB;
}


factoryb.cpp

#include <QDebug>
#include "factoryb.h"


FactoryB::FactoryB()
{
     qDebug()<<"construct FactoryB";
}

ProductA *FactoryB::createProductA()
{
    return new ProductA;
}

ProductB *FactoryB::createProductB()
{
    return new ProductB;
}


product.cpp

#include <QDebug>
#include "product.h"

Product::Product()
{
    qDebug()<<"construct Product";
}

void Product::operationA()
{
    qDebug()<<"Product OperationA";
}

void Product::operationB()
{
    qDebug()<<"Product OperationB";
}


producta.cpp

#include <QDebug>
#include "producta.h"

ProductA::ProductA()
{
    qDebug()<<"construct ProductA";
}

void ProductA::operationA()
{
    qDebug()<<"ProductA operation";
}


productb.cpp

#include <QDebug>
#include "productb.h"

ProductB::ProductB()
{
    qDebug()<<"construct ProductB";
}

void ProductB::operationB()
{
    qDebug()<<"ProductB operation";
}


main.cpp

#include "factory.h"
#include "factorya.h"
#include "factoryb.h"
#include "product.h"

int main(int argc, char **argv)
{
    Factory *factory = new FactoryA;
    Product *product = factory->createProductA();
    product->operationA();
    product = factory->createProductB();
    product->operationB();

    return 0;
}


【运行结果】

construct Factory 
construct FactoryA 
construct Product 
construct ProductA 
ProductA operation 
construct Product 
construct ProductB 
ProductB operation


 

【资源下载】

1 Qt设计模式1-8测试源码：http://download.csdn.net/detail/tandesir/4984275

*之所以发到第8篇博文，才放代码，是希望大家能动手实践。如利用VC平台实现设计模式。如果只是照搬，没有什么意义的。代码可能存在错误，设计模式理解可能也有偏差，恳请指正。
 声明：该源码仅供学习交流，勿用于商业目的。

 

 

转载请标明出处，仅供学习交流，勿用于商业目的

Copyright @ http://blog.csdn.net/tandesir

 

tandesir
关注
专栏目录
Qt下实现简单工厂设计模式
lusanshui的博客
11-30 3960
简述 简单工厂设计模式是一种基础简单而常用的设计模式，对理解封装、继承和多态特性有非常大的帮助。下面就来在Qt下实现简单工厂模式。 代码之路 实现简单工厂至少需要四个类。其中最主要的两个类是工厂类和一个基类，另外的类都是这个基类的继承类。下面的例子中工厂类是factory，基类是BasicClass,两个继承类分别是ClassA和ClassB。 基类BasicClass的实现如下 //basicc...
c++设计模式-工厂方法模式
06-04
工厂方法模式是面向对象设计模式中的一个创建型模式，它提供了一种封装对象创建过程的方式，使得具体的对象创建过程可以延迟到子类中进行。在C++编程中，工厂方法模式广泛应用于各种软件设计中，因为它能有效地解耦...
设计模式系列——三个工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）
记得微笑的专栏
06-01 724
简单工厂模式 当需要加法类的时候，调用工厂类的CreateOperate()，要指定制造的Product 　　例如在大话设计模式P11给的运算工厂例子： 点击(此处)折叠或打开 public static Operation createOperate(string operate) {     Operation o
C++工厂方法模式
weixin_34037173的博客
04-24 488
简述 工厂方法模式（Factory Method Pattern）是一种常用的对象创建型设计模式，此模式的核心思想是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用以及方便后期维护拓展的目的。 简述 模式结构 优缺点 适用场景 案例分析 代码实现 版权所有：一去丶二三里，转载请注明...
Qt C++ 工厂模式
thinkme2010的专栏
06-05 1187
产品类： project.h #pragma once #include class CProject { public: virtual void show() = 0; }; class CProjectA : public CProject { public: CProjectA(); void show() { qDebug()
QT设计模式：工厂模式
buhuiCyvyan的博客
05-05 1008
工厂模式是一种设计模式，用于将对象的创建逻辑与使用者分离，以实现对象的创建和使用的解耦。工厂模式提供了一个统一的接口来创建对象，而客户端代码只需通过该接口来请求所需的对象，而不需要知道具体的对象创建细节。
设计模式之-工厂方法-FactoryMethod
03-22
《设计模式之——工厂方法（Factory Method）》 在软件工程中，设计模式是一种解决常见问题的可重用解决方案，它被广泛应用于构建高质量、可维护的代码。工厂方法是面向对象设计模式的一种，属于创建型模式。这个...
Java设计模式之工厂模式（Factory模式）介绍
09-03
**工厂模式**是一种常见的设计模式，它在Java中被广泛应用于创建对象实例。工厂模式的主要目的是将对象的创建过程封装起来，使得代码更加灵活且易于维护。通过使用工厂模式，我们可以将实例化对象的责任从客户端代码...
创建型设计模式----抽象工厂模式
08-13
抽象工厂模式是创建型设计模式的一种，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定具体类。这种模式的核心在于它允许客户端代码与具体实现细节解耦，使得更换一个产品族变得更为容易。...
设计模式-工厂模式.pdf
04-11
### 设计模式之工厂模式详解 #### 一、概述 工厂模式是一种常用的设计模式，属于创建型模式之一。它的核心思想在于将对象的创建过程封装起来，并通过特定的工厂类来实现对象的创建，以此达到降低系统耦合度的目的...
Qt 工厂模式代码演示
07-15
Qt 工厂模式 最简单的那个。 给初学者一个入门。
qt工厂模式例子qt简单工程模式源码
07-04
参考如下博客，亲自实践了一个QT的工厂模式，亲测可用，编译运行实测。 我用qt5.6，在windows下编译并运行测试，正常。 https://blog.csdn.net/baidu_33570760/article/details/71159808 1. Qt工厂模式源码 2. C++工厂模式源码 3. Qt工厂模式工程 4. Qt工厂模式例程 5. Qt工厂模式例子 6. 简单工厂模式 部分源码实例: // 奔驰工厂 class BenzFactory : public AFactory { public: ICar* CreateCar() { return new BenzCar(); } }; // 宝马工厂 class BmwFactory : public AFactory { public: ICar* CreateCar() { return new BmwCar(); } }; // 奥迪工厂 class AudiFactory : public AFactory { public: ICar* CreateCar() { return new AudiCar(); } }; class AFactory : public QObject { Q_OBJECT public: explicit AFactory(QObject *parent = 0); public: virtual ICar* CreateCar() = 0; // 生产汽车 signals: public slots: };
Qt C++简单工厂模式设计
weixin_47516955的博客
07-15 678
本文主要是c++简单工厂模式使用，可修改读取界面部件文本功能
C++ 设计模式（一）——工厂模式
一个程序猿的工作知识深化日常
05-17 1450
设计模式（一）工厂模式
Qt C++设计模式——简单工厂模式
JuicyActiveGilbert的博客
05-10 727
简单工厂模式介绍 简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。——百度百科 为什么要做？ 因一拍脑袋想做个绘图工具，需要在一个QLabel上绘制多个图形，例如：...
QT设计模式：抽象工厂模式
最新发布
buhuiCyvyan的博客
05-05 718
例如。
Qt之工厂模式（Factory Pattern）
Black_Silencer的博客
05-26 1392
工厂模式 QItemEditorFactory class Q_GUI_EXPORT QItemEditorFactory { public: //按照type，创建对象，具体由创造器（QItemEditorCreatorBase）完成 virtual QWidget *createEditor(QVariant::Type type, QWidget *parent) const; //向工厂注册具体对象的创造器 void registerEditor(QVariant::Type t
Qt学习笔记-仿大佬读取setting文件（简单工厂模式）
IT1995的博客
07-17 4162
文件如下： 程序运行截图如下：   代码如下： widget.h #ifndef WIDGET_H #define WIDGET_H #include &lt;QWidget&gt; #include &lt;QHostAddress&gt; class QSettings; namespace Ui { class Widget; } class ServerCon...
从零开始最简单Qt/C++设计模式总结四：工厂模式（简单工厂、一般工厂及抽象工厂）
少年磊的博客
02-12 2058
代码 基于Qt5.9+mingw32 #include &amp;amp;lt;QCoreApplication&amp;amp;gt; #include &amp;amp;lt;QList&amp;amp;gt; #include &amp;amp;lt;QDebug&amp;amp;gt; ///NOTE:4抽象工厂模式的例子--20190212 ///抽象工厂的作用是统一管理某产品的生产过程（即某类的实例化过程） ///产品A和产品
PHP设计模式：工厂模式详解与应用实例
"PHP设计模式之工厂模式（Factory）入门与应用详解" 在软件开发中，设计模式是一种解决常见问题的可重用方案。工厂模式是其中最基础且常用的一种，尤其在PHP这样的面向对象编程语言中。工厂模式的核心思想是将对象...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值