工厂模式～-EW帮帮网

现实世界中的例子

考虑一个招聘经理的情况。一个人不可能为每一个职位都进行面试。根据职位空缺，她必须决定并将面试步骤委托给不同的人。

用简单的话来说

它提供了一种将实例化逻辑委托给子类的方法。

维基百科的解释

在基于类的编程中，工厂方法模式是一种创建型模式，它使用工厂方法来处理创建对象时无需指定将要创建对象的确切类的问题。这是通过调用工厂方法（在接口中指定并由子类实现，或者在基类中实现并由派生类可选地重写）来创建对象，而不是直接调用构造函数来实现的。

编程示例：

以我们之前的招聘经理为例，首先定义了一个Interviewer接口以及它的几个实现类。

#include <iostream>
#include <memory>

// 面试官接口
class Interviewer {
public:
    virtual void askQuestions() const = 0;
    virtual ~Interviewer() = default;
};

// 开发人员类
class Developer : public Interviewer {
public:
    void askQuestions() const override {
        std::cout << "询问关于设计模式的问题！" << std::endl;
    }
};

// 社区执行官类
class CommunityExecutive : public Interviewer {
public:
    void askQuestions() const override {
        std::cout << "询问关于社区建设的问题" << std::endl;
    }
};

// 招聘经理抽象类
class HiringManager {
public:
    virtual ~HiringManager() = default;

    virtual std::unique_ptr<Interviewer> makeInterviewer() const = 0;

    void takeInterview() const {
        auto interviewer = makeInterviewer();
        interviewer->askQuestions();
    }
};

// 开发经理类
class DevelopmentManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() const override {
        return std::make_unique<Developer>();
    }
};

// 市场经理类
class MarketingManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() const override {
        return std::make_unique<CommunityExecutive>();
    }
};

// 主函数演示功能
int main() {
    DevelopmentManager devManager;
    devManager.takeInterview(); // 输出: 询问关于设计模式的问题！

    MarketingManager marketingManager;
    marketingManager.takeInterview(); // 输出: 询问关于社区建设的问题。

    return 0;
}

Interviewer 接口

首先，我们有一个 Interviewer 接口，所有的面试官类都必须实现这个接口。

class Interviewer {
public:
    virtual void askQuestions() const = 0; // 纯虚函数，子类必须实现
    virtual ~Interviewer() = default; // 虚析构函数，确保子类析构函数被正确调用
};

Developer 类和 CommunityExecutive 类

这两个类实现了 Interviewer 接口。

class Developer : public Interviewer {
public:
    void askQuestions() const override {
        std::cout << "询问关于设计模式的问题！" << std::endl;
    }
};

class CommunityExecutive : public Interviewer {
public:
    void askQuestions() const override {
        std::cout << "询问关于社区建设的问题" << std::endl;
    }
};

HiringManager 抽象类

HiringManager 是一个抽象类，它包含了一个工厂方法 makeInterviewer，用于创建具体的面试官。它还包含一个 takeInterview 方法，该方法使用工厂方法创建的面试官来进行面试。

class HiringManager {
public:
    virtual ~HiringManager() = default; // 虚析构函数

    // 工厂方法，子类必须实现，用于创建面试官
    virtual std::unique_ptr<Interviewer> makeInterviewer() const = 0;

    // 进行面试，使用工厂方法创建的面试官
    void takeInterview() const {
        auto interviewer = makeInterviewer();
        interviewer->askQuestions();
    }
};

具体的 HiringManager 子类

每个具体的招聘经理类（如 DevelopmentManager 和 MarketingManager）实现了 HiringManager 类的工厂方法，以创建特定类型的面试官。

class DevelopmentManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() const override {
        return std::make_unique<Developer>(); // 返回开发人员面试官
    }
};

class MarketingManager : public HiringManager {
public:
    std::unique_ptr<Interviewer> makeInterviewer() const override {
        return std::make_unique<CommunityExecutive>(); // 返回社区执行官面试官
    }
};

主函数

在主函数中，我们创建了 DevelopmentManager 和 MarketingManager 的实例，并调用 takeInterview 方法，展示了不同的面试过程。

int main() {
    DevelopmentManager devManager;
    devManager.takeInterview(); // 输出: 询问关于设计模式的问题！

    MarketingManager marketingManager;
    marketingManager.takeInterview(); // 输出: 询问关于社区建设的问题。

    return 0;
}

类图：

关系说明

Interviewer 接口：

Interviewer 是一个接口，定义了 askQuestions 方法。

Developer 和 CommunityExecutive 类实现了 Interviewer 接口。

HiringManager 抽象类：

HiringManager 是一个抽象类，定义了工厂方法 makeInterviewer 和一个模板方法 takeInterview。

DevelopmentManager 和 MarketingManager 继承了 HiringManager 并实现了 makeInterviewer 方法。

工厂方法模式：

HiringManager 类的 makeInterviewer 方法是一个工厂方法，它的具体实现由子类 DevelopmentManager 和 MarketingManager 提供。

DevelopmentManager 的 makeInterviewer 方法返回 Developer 对象。

MarketingManager 的 makeInterviewer 方法返回 CommunityExecutive 对象。

何时使用：

当类中包含一些通用处理逻辑，但所需的子类是在运行时动态决定的，或者换句话说，当客户端不知道它可能需要哪个具体的子类时，这种模式非常有用。通过定义一个抽象类或接口以及一个或多个工厂方法，可以允许子类在运行时决定实例化哪个类。这增加了代码的灵活性和可扩展性，因为新的子类可以在不修改现有代码的情况下被引入和使用。

在上面的例子中，HiringManager类提供了一个通用的takeInterview方法，但具体的面试官（Interviewer）是在子类中通过makeInterviewer工厂方法动态决定的。这样，当需要添加新的面试官类型时，只需创建一个新的实现Interviewer接口的类，并在相应的招聘经理子类中重写makeInterviewer方法即可。

工厂模式～