1、工厂模式概述：
1.1 简单工厂模式：
简单工厂模式是一种创建型设计模式，它实现了创建对象的功能，但不使用任何具体类的名称。客户端通过调用工厂类的静态方法来创建一个具体的对象，无需关心对象创建的细节。
1.2 工厂方法模式：
工厂方法模式是一种创建型设计模式，它提供了一个接口，用于创建对象，但将实际创建对象的过程推迟到子类中。这样，工厂方法模式允许在运行时根据需要动态地创建对象。
1.3 抽象工厂模式：
抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式可以看作是工厂方法模式的泛化，它允许创建多个对象族。
2、工厂模式的适用场景：
- 当需要在运行时创建多种类型的对象时，可以使用工厂模式。
- 当需要将对象创建与使用分离时，可以使用工厂模式。
- 当需要根据配置、用户输入或其他条件动态地创建对象时，可以使用工厂模式。
2.1 简单工厂模式：
适用于创建相对简单的对象，具有相似的构造过程。例如，一个简单的图形绘制工具，可以创建圆形、矩形和三角形等图形，可以使用简单工厂模式。
2.2 工厂方法模式：
适用于创建具有不同构造过程的对象，需要在运行时根据不同条件创建对象。例如，不同类型的日志记录器，如文件日志记录器、数据库日志记录器等，可以使用工厂方法模式。
2.3 抽象工厂模式：
适用于创建具有相互依赖关系的对象族。例如，跨平台的 GUI 工具箱，需要为不同平台（如 Windows、macOS、Linux）创建一系列相关的 GUI 组件，可以使用抽象工厂模式。
3、工厂模式的优点：
- 将对象的创建和使用分离，降低了客户端与具体产品类之间的耦合，提高了代码的可维护性。
- 可以在运行时动态地创建对象，增加了系统的灵活性。
- 当新增或修改产品类时，客户端代码不需要进行修改，符合开放封闭原则。
4、工厂模式的缺点：
- 当产品种类较多时，工厂类的代码可能变得复杂，难以维护。
- 当需要新增产品时，可能需要修改工厂类的代码，这可能会违反开放封闭原则。
- 抽象工厂模式可能导致大量的类和接口，增加了系统的复杂性。
5、 用C++实现一个简单工厂模式：
#include <iostream>
#include <memory>
class Shape {
public:
virtual void draw() = 0;
};
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Circle" << std::endl;
}
};
class Rectangle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Rectangle" << std::endl;
}
};
class ShapeFactory {
public:
enum class ShapeType { Circle, Rectangle };
static std::unique_ptr<Shape> createShape(ShapeType type) {
switch (type) {
case ShapeType::Circle:
return std::make_unique<Circle>();
case ShapeType::Rectangle:
return std::make_unique<Rectangle>();
default:
return nullptr;
}
}
};
int main() {
auto circle = ShapeFactory::createShape(ShapeFactory::ShapeType::Circle);
circle->draw();
auto rectangle = ShapeFactory::createShape(ShapeFactory::ShapeType::Rectangle);
rectangle->draw();
return 0;
}
在这个例子中，我们定义了一个 Shape 接口，以及 Circle 和 Rectangle 类，它们分别实现了 Shape 接口。接着，我们创建了一个 ShapeFactory 类，它提供了一个静态方法 createShape，根据输入的枚举类型来创建相应的 Shape 对象。最后，在 main 函数中，我们使用 ShapeFactory 创建了 Circle 和 Rectangle 对象，并调用它们的 draw 方法。
6、用C++实现一个工厂方法模式：
#include <iostream>
#include <memory>
class Shape {
public:
virtual void draw() = 0;
};
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Circle" << std::endl;
}
};
class Rectangle : public Shape {
public:
void draw() override {
std::cout << "Drawing a Rectangle" << std::endl;
}
};
class ShapeFactory {
public:
virtual std::unique_ptr<Shape> createShape() = 0;
};
class CircleFactory : public ShapeFactory {
public:
std::unique_ptr<Shape> createShape() override {
return std::make_unique<Circle>();
}
};
class RectangleFactory : public ShapeFactory {
public:
std::unique_ptr<Shape> createShape() override {
return std::make_unique<Rectangle>();
}
};
int main() {
CircleFactory circleFactory;
auto circle = circleFactory.createShape();
circle->draw();
RectangleFactory rectangleFactory;
auto rectangle = rectangleFactory.createShape();
rectangle->draw();
return 0;
}
在这个例子中，我们沿用了之前的 Shape 接口和实现类。接着，我们创建了一个 ShapeFactory 接口，它提供了一个 createShape 方法。然后，我们为每个具体的 Shape 类创建了对应的工厂类（CircleFactory 和 RectangleFactory），它们分别实现了 ShapeFactory 接口。最后，在 main 函数中，我们使用 CircleFactory 和 RectangleFactory 创建了 Circle 和 Rectangle 对象，并调用了它们的 draw 方法。
7、用C++实现一个抽象工厂模式：
#include <iostream>
#include <memory>
class Button {
public:
virtual void click() = 0;
};
class Checkbox {
public:
virtual void check() = 0;
};
class WindowsButton : public Button {
public:
void click() override {
std::cout << "Windows Button clicked" << std::endl;
}
};
class WindowsCheckbox : public Checkbox {
public:
void check() override {
std::cout << "Windows Checkbox checked" << std::endl;
}
};
class MacOSButton : public Button {
public:
void click() override {
std::cout << "MacOS Button clicked" << std::endl;
}
};
class MacOSCheckbox : public Checkbox {
public:
void check() override {
std::cout << "MacOS Checkbox checked" << std::endl;
}
};
class GUIFactory {
public:
virtual std::unique_ptr<Button> createButton() = 0;
virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
};
class WindowsGUIFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<WindowsButton>();
}
std::unique_ptr<Checkbox> createCheckbox() override {
return std::make_unique<WindowsCheckbox>();
}
};
class MacOSGUIFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<MacOSButton>();
}
std::unique_ptr<Checkbox> createCheckbox() override {
return std::make_unique<MacOSCheckbox>();
}
};
int main() {
std::unique_ptr<GUIFactory> factory;
// Assume we determine the platform at runtime.
bool isWindows = true;
if (isWindows) {
factory = std::make_unique<WindowsGUIFactory>();
} else {
factory = std::make_unique<MacOSGUIFactory>();
}
auto button = factory->createButton();
button->click();
auto checkbox = factory->createCheckbox();
checkbox->check();
return 0;
}
在这个例子中，我们创建了两个接口：Button 和 Checkbox，分别表示不同的 GUI 组件。接着，我们创建了两个 Button 和 Checkbox 的实现类，分别表示 Windows 和 macOS 平台上的组件。然后，我们创建了一个 GUIFactory 接口，它提供了两个方法：createButton 和 createCheckbox，用于创建 Button 和 Checkbox 对象。接下来，我们为每个平台创建了对应的工厂类（WindowsGUIFactory 和 MacOSGUIFactory），它们分别实现了 GUIFactory 接口。最后，在 main 函数中，我们根据运行时的平台信息创建了一个工厂对象，并使用该工厂对象创建了 Button 和 Checkbox 对象。
