简单工厂模式、工厂模式、抽象工厂模式
工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种方法来将对象的创建过程与对象的使用过程分离。工厂模式在软件开发中有广泛的应用，适用于不同的场景和需求。下面是几种常见的工厂模式及其应用场景：
1. 简单工厂模式（Simple Factory Pattern）
简单工厂模式通过一个工厂类来创建对象，根据不同的输入参数返回不同的类的实例。
应用场景：
- 对象创建逻辑简单：当对象的创建逻辑相对简单，且不需要复杂的初始化时，可以使用简单工厂模式。
- 减少客户端依赖：客户端只需依赖工厂类，而不需要依赖具体的实现类，降低了耦合性。
示例代码：
#include <iostream>
#include <memory>
class Product {
public:
virtual void use() = 0;
virtual ~Product() = default;
};
class ConcreteProductA : public Product {
public:
void use() override {
std::cout << "Using Product A" << std::endl;
}
};
class ConcreteProductB : public Product {
public:
void use() override {
std::cout << "Using Product B" << std::endl;
}
};
class SimpleFactory {
public:
static std::unique_ptr<Product> createProduct(char type) {
if (type == 'A') {
return std::make_unique<ConcreteProductA>();
} else if (type == 'B') {
return std::make_unique<ConcreteProductB>();
} else {
return nullptr;
}
}
};
int main() {
auto product = SimpleFactory::createProduct('A');
if (product) {
product->use();
}
product = SimpleFactory::createProduct('B');
if (product) {
product->use();
}
return 0;
}
2. 工厂方法模式（Factory Method Pattern）
工厂方法模式通过定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
应用场景：
- 对象创建复杂：当对象的创建过程比较复杂，需要在子类中定制时，可以使用工厂方法模式。
- 增加新产品：当需要增加新产品时，只需添加新的工厂类，不需要修改已有代码，符合开闭原则。
示例代码：
#include <iostream>
#include <memory>
class Product {
public:
virtual void use() = 0;
virtual ~Product() = default;
};
class ConcreteProductA : public Product {
public:
void use() override {
std::cout << "Using Product A" << std::endl;
}
};
class ConcreteProductB : public Product {
public:
void use() override {
std::cout << "Using Product B" << std::endl;
}
};
class Creator {
public:
virtual std::unique_ptr<Product> factoryMethod() const = 0;
virtual ~Creator() = default;
};
class ConcreteCreatorA : public Creator {
public:
std::unique_ptr<Product> factoryMethod() const override {
return std::make_unique<ConcreteProductA>();
}
};
class ConcreteCreatorB : public Creator {
public:
std::unique_ptr<Product> factoryMethod() const override {
return std::make_unique<ConcreteProductB>();
}
};
int main() {
std::unique_ptr<Creator> creatorA = std::make_unique<ConcreteCreatorA>();
auto productA = creatorA->factoryMethod();
productA->use();
std::unique_ptr<Creator> creatorB = std::make_unique<ConcreteCreatorB>();
auto productB = creatorB->factoryMethod();
productB->use();
return 0;
}
3. 抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式提供一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们具体的类。
应用场景：
- 产品族：当需要创建一组相关的或相互依赖的对象时，可以使用抽象工厂模式。
- 平台独立：当系统需要独立于产品的创建和表示时，可以使用抽象工厂模式。
示例代码：
#include <iostream>
#include <memory>
// Abstract Product A
class AbstractProductA {
public:
virtual void use() = 0;
virtual ~AbstractProductA() = default;
};
class ConcreteProductA1 : public AbstractProductA {
public:
void use() override {
std::cout << "Using Product A1" << std::endl;
}
};
class ConcreteProductA2 : public AbstractProductA {
public:
void use() override {
std::cout << "Using Product A2" << std::endl;
}
};
// Abstract Product B
class AbstractProductB {
public:
virtual void use() = 0;
virtual ~AbstractProductB() = default;
};
class ConcreteProductB1 : public AbstractProductB {
public:
void use() override {
std::cout << "Using Product B1" << std::endl;
}
};
class ConcreteProductB2 : public AbstractProductB {
public:
void use() override {
std::cout << "Using Product B2" << std::endl;
}
};
// Abstract Factory
class AbstractFactory {
public:
virtual std::unique_ptr<AbstractProductA> createProductA() const = 0;
virtual std::unique_ptr<AbstractProductB> createProductB() const = 0;
virtual ~AbstractFactory() = default;
};
// Concrete Factory 1
class ConcreteFactory1 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() const override {
return std::make_unique<ConcreteProductA1>();
}
std::unique_ptr<AbstractProductB> createProductB() const override {
return std::make_unique<ConcreteProductB1>();
}
};
// Concrete Factory 2
class ConcreteFactory2 : public AbstractFactory {
public:
std::unique_ptr<AbstractProductA> createProductA() const override {
return std::make_unique<ConcreteProductA2>();
}
std::unique_ptr<AbstractProductB> createProductB() const override {
return std::make_unique<ConcreteProductB2>();
}
};
int main() {
std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
auto productA1 = factory1->createProductA();
auto productB1 = factory1->createProductB();
productA1->use();
productB1->use();
std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
auto productA2 = factory2->createProductA();
auto productB2 = factory2->createProductB();
productA2->use();
productB2->use();
return 0;
}
小结
- 简单工厂模式：适用于对象创建逻辑简单，减少客户端依赖的场景。
- 工厂方法模式：适用于对象创建复杂，需要在子类中定制，以及需要增加新产品的场景。
- 抽象工厂模式：适用于创建一组相关或相互依赖的对象，以及系统需要独立于产品的创建和表示的场景。
根据具体的需求选择合适的工厂模式，可以提高代码的可维护性和扩展性。
