当前位置：首页 > news >正文

工厂模式~

news 来源：原创 2024/5/16 15:30:21

1. 简单工厂

它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。在简单工厂模式中，增加新的产品需要修改工厂类，这违反了开闭原则（对扩展开放，对修改封闭）。

class Product {
public:virtual void Operation() = 0;
};class ConcreteProductA : public Product {
public:void Operation() override {// 实现A产品的操作}
};class ConcreteProductB : public Product {
public:void Operation() override {// 实现B产品的操作}
};class SimpleFactory {
public:static Product* CreateProduct(const std::string& type) {if (type == "A") {return new ConcreteProductA();} else if (type == "B") {return new ConcreteProductB();}return nullptr;}
};

2. 工厂方法

所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类

class Product {
public:virtual void Operation() = 0;
};class ConcreteProductA : public Product {
public:void Operation() override {// 实现A产品的操作}
};class ConcreteProductB : public Product {
public:void Operation() override {// 实现B产品的操作}
};class Creator {
public:virtual Product* FactoryMethod() = 0;
};class ConcreteCreatorA : public Creator {
public:Product* FactoryMethod() override {return new ConcreteProductA();}
};class ConcreteCreatorB : public Creator {
public:Product* FactoryMethod() override {return new ConcreteProductB();}
};

3. 抽象工厂

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

class AbstractProductA {
public:virtual void OperationA() = 0;
};class AbstractProductB {
public:virtual void OperationB() = 0;
};class ConcreteProductA1 : public AbstractProductA {
public:void OperationA() override {// 实现产品A1的操作}
};class ConcreteProductA2 : public AbstractProductA {
public:void OperationA() override {// 实现产品A2的操作}
};class ConcreteProductB1 : public AbstractProductB {
public:void OperationB() override {// 实现产品B1的操作}
};class ConcreteProductB2 : public AbstractProductB {
public:void OperationB() override {// 实现产品B2的操作}
};class AbstractFactory {
public:virtual AbstractProductA* CreateProductA() = 0;virtual AbstractProductB* CreateProductB() = 0;
};class ConcreteFactory1 : public AbstractFactory {
public:AbstractProductA* CreateProductA() override {return new ConcreteProductA1();}AbstractProductB* CreateProductB() override {return new ConcreteProductB1();}
};class ConcreteFactory2 : public AbstractFactory {
public:AbstractProductA* CreateProductA() override {return new ConcreteProductA2();}AbstractProductB* CreateProductB() override {return new ConcreteProductB2();}
};

4. 工厂方法和抽象工厂方法的区别

先让我们通过比喻来理解一下他们的区别，想象你去了一家快餐店。你可以把“工厂方法”想象成是快餐店里的一个单品菜单（比如只卖汉堡的菜单），而“抽象工厂”则像是套餐菜单，套餐里包含了多个不同的食品（比如汉堡、薯条和可乐）。

工厂方法

        在工厂方法中，每一个"工厂"负责制作一种产品。例如，如果你想要一个汉堡，你会去汉堡工厂；如果你想要一包薯条，你会去薯条工厂。每个工厂都有一个方法来“制作”它专门的产品。

        - 汉堡工厂：制作汉堡的方法。
        - 薯条工厂：制作薯条的方法。

你只能从每个工厂得到一种类型的产品。

抽象工厂

        而在**抽象工厂**中，每一个"工厂"可以制作多种相关的产品。例如，你有一个快餐工厂，这个工厂可以同时制作汉堡、薯条和可乐。

        - 快餐工厂：
          - 制作汉堡的方法。
        - 制作薯条的方法。
          - 制作可乐的方法。

你可以从一个工厂获取一系列相互关联的产品。

总体来说，就是

工厂方法：一种工厂对应一种产品。它是一个创建单一产品的方法。

抽象工厂：一种工厂对应多种产品。它是一个创建产品家族的方法。

想象一个具体的需求场景可以帮助理解：

        - 如果你在开发一个应用，需要根据不同的操作系统环境创建不同的UI元素，比如按钮和窗口：
          - 使用工厂方法：你会为每种元素（按钮、窗口）创建一个工厂，每个工厂负责创建在不同操作系统中该元素的具体实例。
          - 使用抽象工厂：你会创建一个工厂，这个工厂能够创建所有需要的UI元素（按钮、窗口），并且这些元素在不同操作系统中有不同的实现。以下是按钮的代码例子。

4.1 工厂方法模式

在工厂方法模式中，我们为每种产品定义了一个创建方法。假设我们有两种类型的UI元素：`Button`和`Window`，我们将为每种元素创建一个工厂。

#include <iostream>
#include <string>// "Product"抽象类
class Button {
public:virtual ~Button()    virtual std::string Draw() const = 0;
};// "ConcreteProduct" 类
class WindowsButton : public Button {
public:std::string Draw() const override {return "Drawing Windows button";}
};class LinuxButton : public Button {
public:std::string Draw() const override {return "Drawing Linux button";}
};// "Creator" 抽象类
class ButtonFactory {
public:virtual ~ButtonFactory()    virtual Button* CreateButton() const = 0;
};// "ConcreteCreator" 类
class WindowsButtonFactory : public ButtonFactory {
public:Button* CreateButton() const override {return new WindowsButton();}
};class LinuxButtonFactory : public ButtonFactory {
public:Button* CreateButton() const override {return new LinuxButton();}
};// 客户端代码
void ClientCode(const ButtonFactory& factory) {Button* button = factory.CreateButton();std::cout << button->Draw() << std::endl;delete button;
}int main() {WindowsButtonFactory* windowsFactory = new WindowsButtonFactory();ClientCode(*windowsFactory);delete windowsFactory;LinuxButtonFactory* linuxFactory = new LinuxButtonFactory();ClientCode(*linuxFactory);delete linuxFactory;
}

在这个工厂方法模式的示例中，我们有一个 `Button` 产品和两个具体产品 `WindowsButton` 和 `LinuxButton`。`ButtonFactory` 是创建者抽象类，而 `WindowsButtonFactory` 和 `LinuxButtonFactory` 是具体的创建者，它们分别创建不同类型的按钮。

4.2 抽象工厂模式

抽象工厂模式为一系列相关或相互依赖的对象创建接口，而不指定它们具体的类。抽象工厂允许客户端使用不同的产品系列，而不必依赖于具体类的实例化。

```cpp
#include <iostream>
#include <string>// 抽象产品类Button
class Button {
public:virtual ~Button()    virtual std::string Draw() const = 0;
};// 抽象产品类Window
class Window {
public:virtual ~Window()    virtual std::string Draw() const = 0;
};// 具体产品类WindowsButton
class WindowsButton : public Button {
public:std::string Draw() const override {return "Drawing Windows button";}
};// 具体产品类LinuxButton
class LinuxButton : public Button {
public:std::string Draw() const override {return "Drawing Linux button";}
};// 具体产品类WindowsWindow
class WindowsWindow : public Window {
public:std::string Draw() const override {return "Drawing Windows window";}
};// 具体产品类LinuxWindow
class LinuxWindow : public Window {
public:std::string Draw() const override {return "Drawing Linux window";}
};// 抽象工厂类GUIFactory
class GUIFactory {
public:virtual ~GUIFactory()    virtual Button* CreateButton() const = 0;virtual Window* CreateWindow() const = 0;
};// 具体工厂类WindowsFactory
class WindowsFactory : public GUIFactory {
public:Button* CreateButton() const override {return new WindowsButton();}Window* CreateWindow() const override {return new WindowsWindow();}
};// 具体工厂类LinuxFactory
class LinuxFactory : public GUIFactory {
public:Button* CreateButton() const override {return new LinuxButton();}Window* CreateWindow() const override {return new LinuxWindow();}
};// 客户端代码
void ClientCode(const GUIFactory& factory) {Button* button = factory.CreateButton();Window* window = factory.CreateWindow();std::cout << button->Draw() << std::endl;std::cout << window->Draw() << std::endl;delete button;delete window;
}int main() {WindowsFactory* windowsFactory = new WindowsFactory();ClientCode(*windowsFactory);delete windowsFactory;LinuxFactory* linuxFactory = new LinuxFactory();ClientCode(*linuxFactory);delete linuxFactory;
}
```

在这个抽象工厂模式的示例中，`GUIFactory` 是一个可以创建按钮和窗口的抽象工厂。`WindowsFactory` 和 `LinuxFactory` 是具体工厂，它们分别创建Windows风格和Linux风格的按钮和窗口。