抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式（Abstract Factory Pattern）

flyfish
2016-01-21
2024-08-01

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口，用于创建一系列相关或依赖对象，而无需指定它们的具体类。这个模式允许客户端使用抽象接口来创建一组相关的对象，从而避免了具体类之间的耦合。

抽象工厂模式 和 工厂方法模式 比较

工厂方法模式：
关注于一个产品的创建。
每个具体工厂负责创建一个产品。

抽象工厂模式：
关注于一系列相关产品的创建。
每个具体工厂负责创建多个相关的产品。

抽象工厂模式的关键组件
抽象工厂（Abstract Factory）：声明了一组用于创建一系列相关对象的抽象方法。
具体工厂（Concrete Factory）：实现了抽象工厂的创建方法，生成具体的产品。
抽象产品（Abstract Product）：声明了一个产品对象的接口。
具体产品（Concrete Product）：实现了抽象产品接口的具体产品对象。
客户端（Client）：通过使用抽象工厂来创建对象，而不是直接使用具体工厂类。

示例1 参考《设计模式之禅》中的Java实现，这里采用C++

抽象工厂（Abstract Factory）：
class AbstractCreator
声明了一组用于创建一系列相关对象的抽象方法（CreateProductA 和 CreateProductB）。

具体工厂（Concrete Factory）：
class Creator1
class Creator2
实现了抽象工厂的创建方法，生成具体的产品（ProductA1, ProductB1, ProductA2, ProductB2）。

抽象产品（Abstract Product）：
class AbstractProductA
class AbstractProductB
声明了一个产品对象的接口。

具体产品（Concrete Product）：
class ProductA1
class ProductA2
class ProductB1
class ProductB2
实现了抽象产品接口的具体产品对象。

客户端（Client）：
int main()
通过使用抽象工厂来创建对象，而不是直接使用具体工厂类

#pragma once
#include <iostream>
#include <memory>

// 抽象产品类A（Abstract Product A）
class AbstractProductA
{
public:
    virtual ~AbstractProductA() = default;
    virtual void ShareMethod() { std::cout << "Shared Method in AbstractProductA\n"; }
    virtual void DoSomething() = 0;
};

// 具体产品A1（Concrete Product A1）
class ProductA1 : public AbstractProductA
{
public:
    void DoSomething() override { std::cout << "ProductA1 doing something.\n"; }
};

// 具体产品A2（Concrete Product A2）
class ProductA2 : public AbstractProductA
{
public:
    void DoSomething() override { std::cout << "ProductA2 doing something.\n"; }
};

// 抽象产品类B（Abstract Product B）
class AbstractProductB
{
public:
    virtual ~AbstractProductB() = default;
    virtual void ShareMethod() { std::cout << "Shared Method in AbstractProductB\n"; }
    virtual void DoSomething() = 0;
};

// 具体产品B1（Concrete Product B1）
class ProductB1 : public AbstractProductB
{
public:
    void DoSomething() override { std::cout << "ProductB1 doing something.\n"; }
};

// 具体产品B2（Concrete Product B2）
class ProductB2 : public AbstractProductB
{
public:
    void DoSomething() override { std::cout << "ProductB2 doing something.\n"; }
};

// 抽象工厂类（Abstract Factory）
class AbstractCreator
{
public:
    virtual ~AbstractCreator() = default;
    virtual std::unique_ptr<AbstractProductA> CreateProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> CreateProductB() = 0;
};

// 具体工厂1类（Concrete Factory 1），生产A1, B1
class Creator1 : public AbstractCreator
{
public:
    std::unique_ptr<AbstractProductA> CreateProductA() override
    {
        return std::make_unique<ProductA1>();
    }

    std::unique_ptr<AbstractProductB> CreateProductB() override
    {
        return std::make_unique<ProductB1>();
    }
};

// 具体工厂2类（Concrete Factory 2），生产A2, B2
class Creator2 : public AbstractCreator
{
public:
    std::unique_ptr<AbstractProductA> CreateProductA() override
    {
        return std::make_unique<ProductA2>();
    }

    std::unique_ptr<AbstractProductB> CreateProductB() override
    {
        return std::make_unique<ProductB2>();
    }
};

// 客户端（Client）
int main()
{
    std::unique_ptr<AbstractCreator> creator1 = std::make_unique<Creator1>();
    std::unique_ptr<AbstractProductA> a1 = creator1->CreateProductA();
    std::unique_ptr<AbstractProductB> b1 = creator1->CreateProductB();
    a1->DoSomething();
    b1->DoSomething();

    std::unique_ptr<AbstractCreator> creator2 = std::make_unique<Creator2>();
    std::unique_ptr<AbstractProductA> a2 = creator2->CreateProductA();
    std::unique_ptr<AbstractProductB> b2 = creator2->CreateProductB();
    a2->DoSomething();
    b2->DoSomething();

    return 0;
}

输出

ProductA1 doing something.
ProductB1 doing something.
ProductA2 doing something.
ProductB2 doing something.

抽象工厂模式实现不同类型的按钮和文本框

下面是一个用C++实现的抽象工厂模式的例子，创建不同类型的按钮和文本框（例如，Windows风格和Mac风格）。
抽象产品（Button 和 TextField）：定义了按钮和文本框的接口。
具体产品（WindowsButton, MacButton, WindowsTextField, MacTextField）：实现了具体的产品类。
抽象工厂（GUIFactory）：声明了创建按钮和文本框的方法。
具体工厂（WindowsFactory, MacFactory）：实现了具体工厂类，生成具体的产品。
客户端（Application）：使用抽象工厂来创建和使用产品对象。

#include <iostream>
#include <memory>

// 抽象产品：按钮
class Button {
public:
    virtual void paint() = 0;
    virtual ~Button() = default;
};

// 具体产品：Windows 按钮
class WindowsButton : public Button {
public:
    void paint() override {
        std::cout << "Rendering a button in Windows style.\n";
    }
};

// 具体产品：Mac 按钮
class MacButton : public Button {
public:
    void paint() override {
        std::cout << "Rendering a button in Mac style.\n";
    }
};

// 抽象产品：文本框
class TextField {
public:
    virtual void draw() = 0;
    virtual ~TextField() = default;
};

// 具体产品：Windows 文本框
class WindowsTextField : public TextField {
public:
    void draw() override {
        std::cout << "Drawing a text field in Windows style.\n";
    }
};

// 具体产品：Mac 文本框
class MacTextField : public TextField {
public:
    void draw() override {
        std::cout << "Drawing a text field in Mac style.\n";
    }
};

// 抽象工厂
class GUIFactory {
public:
    virtual std::unique_ptr<Button> createButton() = 0;
    virtual std::unique_ptr<TextField> createTextField() = 0;
    virtual ~GUIFactory() = default;
};

// 具体工厂：Windows 工厂
class WindowsFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<WindowsButton>();
    }

    std::unique_ptr<TextField> createTextField() override {
        return std::make_unique<WindowsTextField>();
    }
};

// 具体工厂：Mac 工厂
class MacFactory : public GUIFactory {
public:
    std::unique_ptr<Button> createButton() override {
        return std::make_unique<MacButton>();
    }

    std::unique_ptr<TextField> createTextField() override {
        return std::make_unique<MacTextField>();
    }
};

// 客户端
class Application {
private:
    std::unique_ptr<GUIFactory> factory;
    std::unique_ptr<Button> button;
    std::unique_ptr<TextField> textField;

public:
    Application(std::unique_ptr<GUIFactory> factory) : factory(std::move(factory)) {
        button = this->factory->createButton();
        textField = this->factory->createTextField();
    }

    void render() {
        button->paint();
        textField->draw();
    }
};

int main() {
    std::unique_ptr<GUIFactory> factory;

    // 可以根据需要切换不同的工厂
    factory = std::make_unique<WindowsFactory>();
    // factory = std::make_unique<MacFactory>();

    Application app(std::move(factory));
    app.render();

    return 0;
}

输出

Rendering a button in Windows style.
Drawing a text field in Windows style.