dede仿手机网站模板,做旅游攻略的网站,wordpress中文模板下载,深圳软件开发培训推荐文章目录 #xff08;四#xff09;创建型模式#xff1a;简单工厂模式#xff0c;工厂方法模式#xff0c;抽象工厂模式简单工厂模式工厂方法模式抽象工厂模式 #xff08;四#xff09;创建型模式#xff1a;简单工厂模式#xff0c;工厂方法模式#xff0c;抽象工… 文章目录 四创建型模式简单工厂模式工厂方法模式抽象工厂模式简单工厂模式工厂方法模式抽象工厂模式 四创建型模式简单工厂模式工厂方法模式抽象工厂模式
在软件系统中经常面临着创建对象的工作由于需求的变化需要创建的对象的具体类型经常变化。工厂模式的动机在于通过一个专门的工厂类来封装对象的创建过程以解耦对象的使用和创建隐藏复杂的对象实例化逻辑从而提高代码的灵活性和可维护性。通过工厂模式客户端代码只需与工厂接口或抽象类交互而不必直接与具体类耦合这使得系统更易于扩展和修改。
工厂模式可以分为简单工厂模式工厂方法模式和抽象工厂模式。
简单工厂模式
简单工厂模式不属于GoF的23种设计模式工厂类根据输入的参数决定创建哪一种产品类的实例。
#include iostream
#include string// 抽象产品类
class Product {
public:virtual void operation() 0;virtual ~Product() {} // 虚析构函数确保正确释放资源
};// 具体产品类 A
class ConcreteProductA : public Product {
public:void operation() override {std::cout ConcreteProductA operation. std::endl;}
};// 具体产品类 B
class ConcreteProductB : public Product {
public:void operation() override {std::cout ConcreteProductB operation. std::endl;}
};// 简单工厂类
class SimpleFactory {
public:// 静态工厂方法根据传入的字符串类型创建具体的产品对象static Product* createProduct(const std::string type) {if (type A) {return new ConcreteProductA(); // 创建并返回 ConcreteProductA 对象} else if (type B) {return new ConcreteProductB(); // 创建并返回 ConcreteProductB 对象} else {return nullptr; // 如果传入的类型无效返回空指针}}
};int main() {// 使用简单工厂创建产品 AProduct* productA SimpleFactory::createProduct(A);if (productA) {productA-operation();delete productA;}// 使用简单工厂创建产品 BProduct* productB SimpleFactory::createProduct(B);if (productB) {productB-operation();delete productB;}return 0;
}以上代码通过引入一个工厂类SimpleFactory 将产品对象A和B 的创建过程封装在工厂方法中从而实现对象创建与使用的分离。客户端只需要通过工厂来获取对象无需了解对象的创建细节。
工厂方法模式
简单工厂违反了开闭原则对扩展开放对修改关闭因为每当需要引入新产品时都需要修改工厂类。为了避免这个问题工厂方法模式定义一个抽象工厂类通过继承得到可以创建不同产品的工厂。
示例
#include iostream
#include string// 抽象产品类
class Product {
public:virtual void operation() 0;virtual ~Product() {} // 虚析构函数确保正确释放资源
};// 具体产品类 A
class ConcreteProductA : public Product {
public:void operation() override {std::cout ConcreteProductA operation. std::endl;}
};// 具体产品类 B
class ConcreteProductB : public Product {
public:void operation() override {std::cout ConcreteProductB operation. std::endl;}
};// 抽象工厂类
class Factory {
public:virtual Product* createProduct() 0;virtual ~Factory() {} // 虚析构函数确保正确释放资源
};// 具体工厂类 A创建 ConcreteProductA
class ConcreteFactoryA : public Factory {
public:Product* createProduct() override {return new ConcreteProductA();}
};// 具体工厂类 B创建 ConcreteProductB
class ConcreteFactoryB : public Factory {
public:Product* createProduct() override {return new ConcreteProductB();}
};int main() {// 使用具体工厂类 A 创建产品 AFactory* factoryA new ConcreteFactoryA();Product* productA factoryA-createProduct();productA-operation();delete productA;delete factoryA;// 使用具体工厂类 B 创建产品 BFactory* factoryB new ConcreteFactoryB();Product* productB factoryB-createProduct();productB-operation();delete productB;delete factoryB;return 0;
}这段代码通过定义一个抽象工厂类Factory来声明创建产品对象的接口具体的产品创建由具体工厂类ConcreteFactoryA 和 ConcreteFactoryB来实现。工厂方法模式能在不修改已有代码的情况下通过增加新的工厂类来创建新的产品类型实现对开闭原则的遵循。
抽象工厂模式
抽象工厂模式的主要是为了解决在不需要指定具体类的情况下创建一组相关或依赖对象 (产品族)的需求。它通过提供一个接口来创建一系列相关或依赖对象的工厂使得客户端可以在不指定具体实现类的情况下创建产品族中的产品。
#include iostream
#include string// 抽象产品 A 类
class ProductA {
public:virtual void operation() 0;virtual ~ProductA() {} // 虚析构函数确保正确释放资源
};// 具体产品 A1
class ConcreteProductA1 : public ProductA {
public:void operation() override {std::cout ConcreteProductA1 operation. std::endl;}
};// 具体产品 A2
class ConcreteProductA2 : public ProductA {
public:void operation() override {std::cout ConcreteProductA2 operation. std::endl;}
};// 抽象产品 B 类
class ProductB {
public:virtual void operation() 0;virtual ~ProductB() {}
};// 具体产品 B1
class ConcreteProductB1 : public ProductB {
public:void operation() override {std::cout ConcreteProductB1 operation. std::endl;}
};// 具体产品 B2
class ConcreteProductB2 : public ProductB {
public:void operation() override {std::cout ConcreteProductB2 operation. std::endl;}
};// 抽象工厂类
class AbstractFactory {
public:virtual ProductA* createProductA() 0;virtual ProductB* createProductB() 0;virtual ~AbstractFactory() {}
};// 具体工厂 1创建产品 A1 和 B1
class ConcreteFactory1 : public AbstractFactory {
public:ProductA* createProductA() override {return new ConcreteProductA1();}ProductB* createProductB() override {return new ConcreteProductB1();}
};// 具体工厂 2创建产品 A2 和 B2
class ConcreteFactory2 : public AbstractFactory {
public:ProductA* createProductA() override {return new ConcreteProductA2();}ProductB* createProductB() override {return new ConcreteProductB2();}
};int main() {// 使用具体工厂 1 创建产品 A1 和 B1AbstractFactory* factory1 new ConcreteFactory1();ProductA* productA1 factory1-createProductA();ProductB* productB1 factory1-createProductB();productA1-operation();productB1-operation();delete productA1;delete productB1;delete factory1;// 使用具体工厂 2 创建产品 A2 和 B2AbstractFactory* factory2 new ConcreteFactory2();ProductA* productA2 factory2-createProductA();ProductB* productB2 factory2-createProductB();productA2-operation();productB2-operation();delete productA2;delete productB2;delete factory2;return 0;
}
