设计模式-工厂模式

发表于 更新于 分类于

什么是工厂模式？ 工厂顾名思义，就是创建产品。该模式封装和管理对象的创建，通俗地讲就是，你new一个对象的时候，直接调用工厂方法就行了。

工厂模式

  • 当我们需要不停的创建不同的对象的时候，我们可以通过封装接口，然后调用函数返回不同的类型的对象，这个时候我们就需要工厂模式帮我们处理此问题

1. 简单工厂模式

  • 将类的初始化和创建全部交给一个工厂来完成，我们只需要告诉工厂我们需要什么即可。
  • 专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。
  • 是一种实例化对象的方式，只要输入需要实例化对象的名字，就可以通过工厂对象的相应工厂函数来制造你需要的对象。

1. 工厂(Factory)

  • 负责创建所有实例的内部逻辑，工厂类可以被外界直接调用，创建所需要的产品对象。
  • 创建出产品(Product) -> 具体的产品(ConcreteProduct)

2. 产品

抽象产品
  • 象产品角色是简单工厂模式所创建的所有对象的父类，负责描述所有实例所共有的公告接口。所创建的具体产品对象都是其派生对象。
具体产品
  • 具体产品是简单工厂模式的创建目标。每个具体产品都继承了抽象产品，需要实现定义在抽象产品中的方法。

3. 使用

  • 当我们需要创建的对象数量较多且杂的时候，我们需要使用简单工厂模式来创建对象。
  • 对象的创建过程是我们不需要去关心，我们注重的是对象的实际操作，所以，我们需要分离对象的创建和操作两部分，方便后期的程序扩展和维护。

4. Code

  • Product
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <string>
enum class product_type
{
    none,
    one,
    two
    // ...... 
};

class Product
{
public:
    Product() = default;
    ~Product() = default;
    virtual const std::string & name()
    {
        return m_name;
    }
private:
    std::string m_name;
};

class ProductA final :public Product
{
public:
    ProductA() = default;
    ~ProductA() = default;
    virtual const std::string& name()
    {
        return m_name;
    }
private:
    std::string m_name;
};

class ProductB final :public Product
{
public:
    ProductB() = default;
    ~ProductB() = default;
    virtual const std::string& name()
    {
        return m_name;
    }
private:
    std::string m_name;
};


  • Factoy.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
---
Factoy.h
---
class Factory
{
public:
    Factory() = default;
    ~Factory() = default;
    virtual  Product* crteateProduct(product_type & type)
    {
        if(type == product_type::one)
        {
            return new  ProductA;
        }
        if(type == product_type::two)
        {
            return new ProductB;
        }
        else
        {
            return nullptr;
        }
    }
    virtual Product* crteateProduct(){};
};

  • main
1
2
3
4
5
6
int main()
{
    const auto factory = new Factory;
    auto product_a = factory->crteateProduct(product_type::none);
    return 0;
}

2. 工厂方法模式

2.1 简介

  • 简单工厂模式中最大的缺点就是当我们需要创建新的产品的时候，我们需要修改工厂的create方法，加入必要的处理逻辑，违背了设计原则-开闭原则
  • 工厂方法模式中，工厂父类只是定义创建产品的接口，子类负责创建具体的产品，将具体产品的创建都延迟到子类中实现，通过子类创建具体的实例化对象。

实现

  • concreteFactory.h
1
2
3
4
5
6
7
8
9
10
11
#include "Factory.h"
class FactoryA final : public Factory
{
public:
    FactoryA() = default;
    ~FactoryA() = default;
    Product* crteateProduct() override
    {
        return new ProductA;
    }
};
  • main.cpp
1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include "Factory.h"
#include "concreteFactory.h"

int main()
{
    const auto factory = new FactoryA;
    auto product_a = factory->crteateProduct();
    return 0;
}

3. 抽象工厂模式

  • 一个特殊的工厂模式
  • 创建一个产品族
  • 待续