工厂方法模式与抽象工厂模式
工厂方法模式 (Factory Method)
定义： 工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但让子类决定实例化哪个类。工厂方法将类的实例化推迟到子类。
优点：
- 解耦：客户端代码与具体的产品类解耦，只依赖于产品的接口。
- 可扩展性：新增产品只需实现相应的工厂方法，无需修改现有代码。
- 灵活性：可以根据具体需求选择不同的产品。
应用场景：
- 当一个类不知道它所需要的对象的类时。
- 当一个类希望通过子类来指定所创建的对象时。
- 当类的实例化过程非常复杂时。
C++ 示例代码
以下是一个简单的工厂方法模式示例，展示了如何创建不同类型的汽车。
1. 产品接口
首先，我们定义一个汽车的接口。
#include
#include
// 产品接口
class Car {
public:
virtual void drive() = 0; // 驾驶方法
virtual ~Car() = default; // 虚析构函数
};
2. 具体产品
接下来，我们定义具体的汽车类，分别实现 Car 接口。
// 具体产品：轿车
class Sedan : public Car {
public:
void drive() override {
std::cout << "Driving a Sedan.\n";
}
};
// 具体产品：SUV
class SUV : public Car {
public:
void drive() override {
std::cout << "Driving an SUV.\n";
}
};
3. 工厂接口
然后，我们定义一个工厂接口，用于创建汽车对象。
// 工厂接口
class CarFactory {
public:
virtual std::unique_ptr createCar() = 0; // 工厂方法
virtual ~CarFactory() = default; // 虚析构函数
};
4. 具体工厂
实现具体工厂类，分别创建不同类型的汽车。
// 具体工厂：轿车工厂
class SedanFactory : public CarFactory {
public:
std::unique_ptr createCar() override {
return std::make_unique(); // 创建轿车
}
};
// 具体工厂：SUV工厂
class SUVFactory : public CarFactory {
public:
std::unique_ptr createCar() override {
return std::make_unique(); // 创建SUV
}
};
5. 客户端代码
最后，我们在客户端代码中使用这些工厂。
int main() {
// 创建轿车工厂并生产轿车
std::unique_ptr sedanFactory = std::make_unique();
std::unique_ptr sedan = sedanFactory->createCar();
sedan->drive(); // 输出: Driving a Sedan.
// 创建SUV工厂并生产SUV
std::unique_ptr suvFactory = std::make_unique();
std::unique_ptr suv = suvFactory->createCar();
suv->drive(); // 输出: Driving an SUV.
return 0;
}
总结
在这个示例中，工厂方法模式允许我们通过不同的工厂类创建不同类型的汽车。客户端代码只需要依赖于 CarFactory 和 Car 接口，而不需要了解具体的汽车实现。这种解耦设计提高了代码的灵活性和可维护性，便于未来的扩展。
- 抽象工厂模式
抽象工厂模式 (Abstract Factory)
定义： 抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。通过这种方式，抽象工厂模式可以使客户端代码与具体产品的实现解耦。
优点：
- 解耦：客户端不需要依赖具体产品类，可以通过抽象接口进行交互。
- 可扩展性：如果需要增加新的产品，只需实现新的工厂和产品类，无需修改现有代码。
- 一致性：确保产品之间的兼容性和一致性。
应用场景：
- 当系统需要独立于其产品的创建、组合和表示时。
- 当系统需要根据不同的配置来生成一系列相关的产品时。
C++ 示例代码
以下是一个简单的抽象工厂模式示例，展示了如何创建不同类型的家具（椅子和沙发）。
1. 产品接口
首先，我们定义椅子和沙发的接口。
#include
#include
// 椅子接口
class Chair {
public:
virtual void sitOn() = 0; // 坐下的方法
virtual ~Chair() = default; // 虚析构函数
};
// 沙发接口
class Sofa {
public:
virtual void lieOn() = 0; // 躺下的方法
virtual ~Sofa() = default; // 虚析构函数
};
2. 具体产品
接下来，我们定义具体的椅子和沙发类。
// 具体产品：现代椅子
class ModernChair : public Chair {
public:
void sitOn() override {
std::cout << "Sitting on a Modern Chair.\n";
}
};
// 具体产品：古典椅子
class VictorianChair : public Chair {
public:
void sitOn() override {
std::cout << "Sitting on a Victorian Chair.\n";
}
};
// 具体产品：现代沙发
class ModernSofa : public Sofa {
public:
void lieOn() override {
std::cout << "Lying on a Modern Sofa.\n";
}
};
// 具体产品：古典沙发
class VictorianSofa : public Sofa {
public:
void lieOn() override {
std::cout << "Lying on a Victorian Sofa.\n";
}
};
3. 抽象工厂
然后，我们定义一个抽象工厂接口，用于创建椅子和沙发。
// 抽象工厂接口
class FurnitureFactory {
public:
virtual std::unique_ptr createChair() = 0; // 创建椅子的方法
virtual std::unique_ptr createSofa() = 0; // 创建沙发的方法
virtual ~FurnitureFactory() = default; // 虚析构函数
};
4. 具体工厂
实现具体工厂类，分别创建现代和古典家具。
// 具体工厂：现代家具工厂
class ModernFurnitureFactory : public FurnitureFactory {
public:
std::unique_ptr createChair() override {
return std::make_unique(); // 创建现代椅子
}
std::unique_ptr createSofa() override {
return std::make_unique(); // 创建现代沙发
}
};
// 具体工厂：古典家具工厂
class VictorianFurnitureFactory : public FurnitureFactory {
public:
std::unique_ptr createChair() override {
return std::make_unique(); // 创建古典椅子
}
std::unique_ptr createSofa() override {
return std::make_unique(); // 创建古典沙发
}
};
5. 客户端代码
最后，我们在客户端代码中使用这些工厂。
int main() {
// 创建现代家具工厂
std::unique_ptr modernFactory = std::make_unique();
std::unique_ptr modernChair = modernFactory->createChair();
std::unique_ptr modernSofa = modernFactory->createSofa();
modernChair->sitOn(); // 输出: Sitting on a Modern Chair.
modernSofa->lieOn(); // 输出: Lying on a Modern Sofa.
// 创建古典家具工厂
std::unique_ptr victorianFactory = std::make_unique();
std::unique_ptr victorianChair = victorianFactory->createChair();
std::unique_ptr victorianSofa = victorianFactory->createSofa();
victorianChair->sitOn(); // 输出: Sitting on a Victorian Chair.
victorianSofa->lieOn(); // 输出: Lying on a Victorian Sofa.
return 0;
}
总结
在这个示例中，抽象工厂模式允许我们通过不同的工厂类创建不同类型的家具（椅子和沙发）。客户端代码只依赖于 FurnitureFactory 和产品接口，而不需要了解具体的家具实现。这种解耦设计提高了代码的灵活性和可维护性，便于未来的扩展和修改。通过这种模式，可以确保创建的家具产品之间的一致性和相互适配。