【C++ | 设计模式】抽象工厂模式的详解与实现
1. 概念
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。它允许客户端代码通过工厂接口来创建一组对象，而无需了解它们的具体实现细节。
2. 结构
抽象工厂模式通常包括以下几个角色：
-
AbstractFactory: 抽象工厂接口，声明了创建一系列产品的方法。
-
ConcreteFactory: 具体工厂，实现
AbstractFactory接口，创建具体的产品对象。 -
AbstractProduct: 抽象产品接口，为每种产品定义一个接口。
-
ConcreteProduct: 具体产品，实现
AbstractProduct接口，提供产品的具体实现。 -
Client: 使用抽象工厂和抽象产品接口来实现业务逻辑，无需了解具体的产品类。
3. UML 结构图：
4. 优缺点
优点:
- 解耦: 客户端与具体的产品类解耦，客户端只需依赖于抽象接口。
- 扩展性: 增加新的产品系列时，只需添加新的工厂和产品类，客户端代码不需要修改。
- 一致性: 可以确保一组产品的一致性，因为工厂创建的产品彼此兼容。
缺点:
- 增加系统复杂性: 由于需要增加许多抽象类和具体类，系统结构变得复杂。
- 难以支持新产品: 如果需要支持新的产品类型，可能需要修改工厂接口，影响已有的代码。
5. 适用场景
- 多种产品的系列: 当系统需要处理一系列相关的产品，但客户端代码不知道具体的产品类时，抽象工厂模式是合适的选择。
- 产品兼容性: 当系统中的产品需要保持一致性或兼容性时（例如，一个操作系统的UI库），抽象工厂模式可以帮助管理和维护这些产品的一致性。
- 产品家族: 需要在产品家族中选择不同的产品时（例如，不同操作系统上的UI组件），抽象工厂模式提供了一种优雅的解决方案。
6. 代码示例
工厂方法模式要求产品必须为同一类型，也就是说，BBA 的工厂只能生产各自的汽车，要生产其他产品（例如：自行车）是不行的，这显然限制了产品的扩展。为了解决这个问题，抽象工厂模式出现了 - 将产品归类分组，然后将好几组产品构成一族。每个工厂负责生产一族产品，而工厂中的每个方法负责生产一种类型的产品。
这样，客户端只需要创建具体工厂的实例，然后调用工厂对象的工厂方法就可以得到所需要的产品对象。
#include <iostream>
#include <string>
// 抽象产品：汽车
class Car {
public:
virtual void drive() = 0; // 纯虚函数：驱动汽车
};
// 具体产品：奔驰汽车
class MercedesCar : public Car {
public:
void drive() override {
std::cout << "Driving a Mercedes car." << std::endl;
}
};
// 具体产品：宝马汽车
class BMWCar : public Car {
public:
void drive() override {
std::cout << "Driving a BMW car." << std::endl;
}
};
// 具体产品：奥迪汽车
class AudiCar : public Car {
public:
void drive() override {
std::cout << "Driving an Audi car." << std::endl;
}
};
// 抽象产品：自行车
class Bicycle {
public:
virtual void ride() = 0; // 纯虚函数：骑自行车
};
// 具体产品：奔驰自行车
class MercedesBicycle : public Bicycle {
public:
void ride() override {
std::cout << "Riding a Mercedes bicycle." << std::endl;
}
};
// 具体产品：宝马自行车
class BMWBicycle : public Bicycle {
public:
void ride() override {
std::cout << "Riding a BMW bicycle." << std::endl;
}
};
// 具体产品：奥迪自行车
class AudiBicycle : public Bicycle {
public:
void ride() override {
std::cout << "Riding an Audi bicycle." << std::endl;
}
};
// 抽象工厂
class VehicleFactory {
public:
virtual Car* createCar() = 0; // 纯虚函数：创建汽车
virtual Bicycle* createBicycle() = 0; // 纯虚函数：创建自行车
};
// 具体工厂：奔驰工厂
class MercedesFactory : public VehicleFactory {
public:
Car* createCar() override {
return new MercedesCar(); // 创建奔驰汽车
}
Bicycle* createBicycle() override {
return new MercedesBicycle(); // 创建奔驰自行车
}
};
// 具体工厂：宝马工厂
class BMWFactory : public VehicleFactory {
public:
Car* createCar() override {
return new BMWCar(); // 创建宝马汽车
}
Bicycle* createBicycle() override {
return new BMWBicycle(); // 创建宝马自行车
}
};
// 具体工厂：奥迪工厂
class AudiFactory : public VehicleFactory {
public:
Car* createCar() override {
return new AudiCar(); // 创建奥迪汽车
}
Bicycle* createBicycle() override {
return new AudiBicycle(); // 创建奥迪自行车
}
};
// 客户端代码：使用工厂创建产品
void testVehicleFactory(VehicleFactory* factory) {
Car* car = factory->createCar(); // 创建汽车
Bicycle* bicycle = factory->createBicycle(); // 创建自行车
car->drive(); // 驱动汽车
bicycle->ride(); // 骑自行车
delete car; // 释放汽车内存
delete bicycle; // 释放自行车内存
}
int main() {
VehicleFactory* factory = new MercedesFactory(); // 使用奔驰工厂
testVehicleFactory(factory);
delete factory;
factory = new BMWFactory(); // 使用宝马工厂
testVehicleFactory(factory);
delete factory;
factory = new AudiFactory(); // 使用奥迪工厂
testVehicleFactory(factory);
delete factory;
return 0;
}