简单工厂模式和抽象工厂模式的区别
时间: 2023-07-14 19:10:13 浏览: 134
简单工厂模式和抽象工厂模式是两种不同的创建型设计模式,它们在实现上有一些区别。
简单工厂模式(Simple Factory Pattern):
- 简单工厂模式通过一个工厂类来创建对象,客户端通过调用工厂类的静态方法或非静态方法来获取所需的具体产品对象。
- 工厂类根据客户端传入的参数来决定创建哪种具体产品的对象。
- 简单工厂模式只有一个具体工厂类,负责创建所有类型的产品对象。
抽象工厂模式(Abstract Factory Pattern):
- 抽象工厂模式通过引入一个抽象工厂接口和多个具体工厂类来创建对象。
- 抽象工厂接口定义了一系列创建产品的方法,每个具体工厂类负责实现这些方法以创建特定类型的产品对象。
- 客户端通过使用特定的具体工厂类来创建一组相关的产品对象,这样可以保证这些产品对象在一起使用时能够协调和兼容。
主要区别:
- 简单工厂模式只有一个工厂类,所有产品的创建逻辑集中在该类中。而抽象工厂模式引入了多个具体工厂类,每个具体工厂类负责创建一组相关的产品。
- 简单工厂模式创建的是单个产品对象,而抽象工厂模式创建的是一组相关的产品对象。
- 简单工厂模式的客户端只与工厂类交互,而抽象工厂模式的客户端与抽象工厂接口以及具体工厂类交互。客户端可以通过替换具体工厂类来改变创建不同产品的行为。
选择使用简单工厂模式还是抽象工厂模式取决于具体的应用场景和需求。简单工厂模式适用于创建单一类型的产品对象,而抽象工厂模式适用于创建一组相关的产品对象。
相关问题
C++实现简单工厂模式和抽象工厂模式
简单工厂模式:
简单工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。在简单工厂模式中,我们创建对象而无需向客户端暴露创建逻辑。这种类型的设计模式属于创建型模式,提供了一种创建对象的最佳方式。
C++代码实现:
```c++
#include <iostream>
using namespace std;
// 抽象产品
class Product {
public:
virtual void Show() = 0;
};
// 具体产品 A
class ConcreteProductA : public Product {
public:
void Show() {
cout << "ConcreteProductA Show" << endl;
}
};
// 具体产品 B
class ConcreteProductB : public Product {
public:
void Show() {
cout << "ConcreteProductB Show" << endl;
}
};
// 工厂类
class Factory {
public:
Product* CreateProduct(int type) {
switch (type) {
case 1:
return new ConcreteProductA();
case 2:
return new ConcreteProductB();
default:
return nullptr;
}
}
};
int main() {
Factory factory;
Product* productA = factory.CreateProduct(1);
if (productA != nullptr) {
productA->Show();
}
Product* productB = factory.CreateProduct(2);
if (productB != nullptr) {
productB->Show();
}
delete productA;
delete productB;
return 0;
}
```
抽象工厂模式:
抽象工厂模式是一种创建型设计模式,它提供了一种创建一系列相关或依赖对象的最佳方式。抽象工厂模式的基本思想是提供一个接口,用于创建与产品簇相关的一族对象,而不需要明确指定它们的类。
C++代码实现:
```c++
#include <iostream>
using namespace std;
// 抽象产品 A
class AbstractProductA {
public:
virtual void Show() = 0;
};
// 具体产品 A1
class ProductA1 : public AbstractProductA {
public:
void Show() {
cout << "ProductA1 Show" << endl;
}
};
// 具体产品 A2
class ProductA2 : public AbstractProductA {
public:
void Show() {
cout << "ProductA2 Show" << endl;
}
};
// 抽象产品 B
class AbstractProductB {
public:
virtual void Show() = 0;
};
// 具体产品 B1
class ProductB1 : public AbstractProductB {
public:
void Show() {
cout << "ProductB1 Show" << endl;
}
};
// 具体产品 B2
class ProductB2 : public AbstractProductB {
public:
void Show() {
cout << "ProductB2 Show" << endl;
}
};
// 抽象工厂
class AbstractFactory {
public:
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};
// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProductA* CreateProductA() {
return new ProductA1();
}
AbstractProductB* CreateProductB() {
return new ProductB1();
}
};
// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:
AbstractProductA* CreateProductA() {
return new ProductA2();
}
AbstractProductB* CreateProductB() {
return new ProductB2();
}
};
int main() {
AbstractFactory* factory = new ConcreteFactory1();
AbstractProductA* productA = factory->CreateProductA();
AbstractProductB* productB = factory->CreateProductB();
productA->Show();
productB->Show();
delete productA;
delete productB;
factory = new ConcreteFactory2();
productA = factory->CreateProductA();
productB = factory->CreateProductB();
productA->Show();
productB->Show();
delete productA;
delete productB;
delete factory;
return 0;
}
```
工厂模式和抽象工厂模式的区别
工厂模式和抽象工厂模式都是创建型设计模式,用于创建对象。它们有一些相似之处,但也有一些重要的区别。
工厂模式是一种创建型设计模式,它定义了一个用于创建对象的接口,但是让子类决定实例化哪个类。这种模式使得一个类的实例化延迟到其子类。工厂模式适用于需要创建的对象较少的情况,因为每增加一个产品,就需要增加一个具体的工厂类,这样会导致类的数量增加,不利于系统的维护和扩展。
抽象工厂模式是一种创建型设计模式,它提供了一个接口,用于创建相关或依赖对象的家族,而不需要明确指定具体类。抽象工厂模式适用于需要创建的对象较多的情况,因为它可以通过增加一个具体的工厂类来增加一个产品族,而不需要修改已有的代码。但是,如果需要增加一个产品等级结构,就需要修改所有的具体工厂类,这样会违背开闭原则。
因此,工厂模式适用于需要创建的对象较少,但是需要频繁添加新的产品的情况,而抽象工厂模式适用于需要创建的对象较多,但是不需要频繁添加新的产品等级结构的情况。