[抽象]工厂模式（[Abstract] Factory）——创建型模式

[抽象]工厂模式——创建型模式

什么是抽象工厂？

抽象工厂模式是一种创建型设计模式，让你能够保证在客户端程序中创建一系列有依赖的对象组时，无需关心这些对象的类型。

具体来说：

• 对象的创建与使用分离： 抽象工厂模式通过引入抽象工厂接口以及具体工厂类，将对象的创建与使用分离开来。这使得客户端代码与具体的产品类解耦，提高了系统的灵活性和可维护性。
• 产品族的创建： 在某些情况下，一个系统需要一组相关或相互依赖的对象，而不是单个对象。抽象工厂模式可以方便地创建整个产品族，确保这些对象之间的兼容性和一致性。
• 更易于替换产品系列： 通过使用抽象工厂模式，可以轻松地替换整个产品系列，而无需修改客户端代码。只需要更改具体工厂的实现即可实现产品族的变更，这种灵活性对于系统的扩展和维护非常有用。
• 隐藏实现细节： 抽象工厂模式隐藏了实际产品的创建细节，客户端只需与抽象工厂接口进行交互，而不必关心具体产品是如何创建的。这有助于保持代码的简洁性和可读性。

什么是工厂模式？

对于工厂模式和抽象工厂模式的区别，个人认为：
工厂模式——工厂和产品是一对一的关系，即每个工厂只负责一个产品。
抽象工厂模式——工厂和产品是一对多的关系，即每个工厂负责一个产品族。
1
2
3

C++实现一版抽象工厂的例子：

说明：（个人理解总结）

• 将工厂抽象的意义：产品系列的划分由后端写入到实体工厂中，客户端只需感知一个抽象工厂接口（传给客户端什么实体工厂，客户端就用什么），需要产品时由工厂代为构建，客户端只管使用产品所提供的方法即可，无需关注产品属于哪个系列。实现客户端与具体产品的解耦。
• 将产品抽象的意义：在客户端通过工厂创建出产品后，此时这个产品的系列是不确定的（系列取决于实体工厂中的指定），此时为了实现客户端与产品的解耦，需要用抽象产品引用或指针进行接收。

/*************************************************************************
        > File Name: AbstractFactory.cpp
        > Author:
        > Mail:
        > Created Time: Fri Mar  8 14:51:39 2024
 ************************************************************************/

#include <iostream>

using namespace std;

// Abstarct product(File)
class AbstractFile {
public:
    virtual ~AbstractFile() = default;
    virtual void f_open() = 0;
};

class File_Linux : public AbstractFile {
public:
    void f_open() override {
        // The logic of opening files in Linux.
        cout << "Opening files successful in Linux !!!" << endl;
        return ;
    }
};

class File_Windows : public AbstractFile {
public:
    void f_open() override {
        // The logic of opening files in Windows.
        cout << "Opening files successful in Windows !!!" << endl;
        return ;
    }
};

// Abstract product(Process)
class AbstractProcess {
public:
    virtual ~AbstractProcess() = default;
    virtual void create() = 0;
};

class Process_Linux : public AbstractProcess {
public:
    void create() override {
        // The logic of create process in Linux.
        cout << "Create process successful in Linux !!!" << endl;
        return ;
    }
};

class Process_Windows : public AbstractProcess {
public:
    void create() override {
        // The logic of create process in Windows.
        cout << "Create process successful in Windows !!!" << endl;
        return ;
    }
};


// Abstarct Factory(Creating Product)
class AbstractFactory {
public:
    virtual AbstractFile* CreateFile() = 0;
    virtual AbstractProcess* CreateProcess() = 0;
};

class LinuxFactory : public AbstractFactory {
public:
    AbstractFile* CreateFile() override {
        return new File_Linux();
    }
    AbstractProcess* CreateProcess() override {
        return new Process_Linux();
    }
};

class WindowsFactory : public AbstractFactory {
public:
    AbstractFile* CreateFile() override {
        return new File_Windows();
    }
    AbstractProcess* CreateProcess() override {
        return new Process_Windows();
    }
};

void ClientCode(AbstractFactory *factoy_obj) {
    AbstractFile *file = factoy_obj->CreateFile();
    file->f_open();
    AbstractProcess *process = factoy_obj->CreateProcess();
    process->create();
    delete file;
    delete process;
};

int main() {
    LinuxFactory ins_linux;
    ClientCode(&ins_linux);
    WindowsFactory ins_windows;
    ClientCode(&ins_windows);
    return 0;
}
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105