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

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

什么是抽象工厂？

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

具体来说：

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

什么是工厂模式？

复制代码

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

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

说明：（个人理解总结）

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

cpp 复制代码

/*************************************************************************
        > 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;
}