设计模式（3）——工厂方法 Factory Method

最新推荐文章于 2024-01-08 19:34:17 发布

leonliu06

最新推荐文章于 2024-01-08 19:34:17 发布

阅读量452

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ 设计模式设计模式文章标签： c++ 设计模式

本文链接：https://blog.youkuaiyun.com/leonliu06/article/details/78446318

C++ 同时被 3 个专栏收录

25 篇文章

订阅专栏

设计模式

24 篇文章

订阅专栏

设计模式

24 篇文章

订阅专栏

本文深入探讨了工厂方法设计模式的应用场景、实现原理及其优势。通过一个C++示例项目，详细介绍了如何通过定义创建对象的接口来封装实例化过程，并展示了这种模式如何使系统更加灵活且易于扩展。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计模式学习笔记首页
 设计模式（1）——抽象工厂 AbstractFactory
设计模式（2）——生成器 Builder
设计模式（3）——工厂方法 Factory Method
设计模式（4）——原型 Prototype
设计模式（5）——单例 Singleton
设计模式（6）——适配器 Adapter
设计模式（7）——桥接 Bridge
设计模式（8）——组合 Composite
设计模式（9）——装饰 Decorator
设计模式（10）——外观 Facade
设计模式（11）——享元 Flyweight
设计模式（12）——代理 Proxy
设计模式（13）——职责链 Chain Of Responsibility
设计模式（14）——命令 Command
设计模式（15）——解释器 Interpreter
设计模式（16）——迭代器 Iterator
设计模式（17）——中介者 Mediator
设计模式（18）——备忘录 Memento
设计模式（19）——观察者 Observer
设计模式（20）——状态 State
设计模式（21）——策略 Strategy
设计模式（22）——模板方法 Template Method
设计模式（23）——访问者 Visitor

三、Factory Method（工厂方法，对象创建型模式）

1. 问题：

1. 当使用抽象基类或接口的子类时（多态），必须编写诸如 new xxx; 的代码。这带来了两个问题：
    1. 程序员必须知道子类的名称
    2. 扩展性和维护变得越来越困难
2. 知道具体要实例化哪一个具体的子类

2. 功能：

定义创建对象的接口，封装了对象的创建
类的工作延迟到了子类中

3. 意图：

封装对象的创建过程，让系统与具体对象解耦。

4. 类图：

5. 中间层思考：

工厂类在客户（或程序员或系统）与产品（具体对象）的直接生成之间添加了一个中间层。

6. C++实现：

1. 编写工厂接口、产品接口
2. 工厂接口中编写生成产品的方法 `Product* CreateProduct();`
3. 工厂接口实现类中编写具体生成的产品对象（延迟实例化）

Factory.h

// Factory.h
#ifndef _FACTORY_H_
#define _FACTORY_H_

class Product;

class Factory {
public:
    virtual ~Factory() = 0;
    virtual Product* CreateProduct() = 0;
protected:
    Factory();
private:

};

class ConcreteFactory :public Factory
{
public:
    ~ConcreteFactory();
    ConcreteFactory();
    Product* CreateProduct();
protected:
private:
};


#endif // !_FACTORY_H_

Factory.cpp

//Factory.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream>
using namespace std;
Factory::Factory()
{
}

Factory::~Factory() {}

ConcreteFactory::ConcreteFactory()
{
    cout << "ConcreteFactory....." << endl;
}
ConcreteFactory::~ConcreteFactory()
{
}
Product* ConcreteFactory::CreateProduct()
{
    return new ConcreteProduct();
}

Product.h

// Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class Product {
public:
    virtual ~Product() = 0;
protected:
    Product();
private:

};

class ConcreteProduct:public Product {
public:
    ~ConcreteProduct();
    ConcreteProduct();
protected:
private:

};

#endif // !_PRODUCT_H_

Product.cpp

// Product.cpp
#include "Product.h"
#include "Factory.h"

#include <iostream>

using namespace std;

Product::Product() {

}

Product::~Product() {

}

ConcreteProduct::ConcreteProduct() {
    cout << "concrete product..." << endl;
}

ConcreteProduct::~ConcreteProduct() {

}

main.cpp

// main.cpp
#include <istream>
#include "Factory.h"
#include "Product.h"
using namespace std;

int main(int argc, char* argv[])
{
    Factory* fac = new ConcreteFactory();
    Product* p = fac->CreateProduct();
    return 0;
}