工厂模式是一种创建型设计模式,它的主要目的是隐藏对象的创建过程,将对象的创建和使用分离开来。这样可以在不改变现有代码的情况下添加新的产品类,并且可以通过对工厂类进行修改来改变对象的创建过程。
工厂模式主要由三个角色组成:
抽象产品类:定义产品的共性,可以是一个抽象类或接口。
具体产品类:实现抽象产品类定义的接口,由工厂类创建,每个具体产品类都对应一个具体工厂类。
工厂类:创建产品对象的工厂,它包含一个创建产品的方法,该方法可以根据传入的参数来创建不同的产品对象。工厂类可以是抽象类或接口,也可以是一个普通类。
工厂模式有两种常见的实现方式:简单工厂模式和工厂方法模式。
简单工厂模式:简单工厂模式是通过一个工厂类来创建所有的产品对象。工厂类通常包含一个静态方法,根据传入的参数来决定创建哪种产品对象。简单工厂模式的优点是实现简单,但缺点是工厂类负责创建所有的产品对象,如果产品类型过多,会导致工厂类过于庞大,难以维护。
工厂方法模式:工厂方法模式是将工厂类抽象出来,每个具体产品类都对应一个具体工厂类,工厂类负责创建与之对应的产品对象。工厂方法模式的优点是可以支持扩展,每个产品类都有一个与之对应的工厂类,新产品的加入不会影响已有产品的代码。缺点是需要创建很多的工厂类。
下面是一个简单工厂模式的示例代码:
// 抽象产品类
class Product {
public:
virtual void use() = 0;
};
// 具体产品类1
class ConcreteProduct1 : public Product {
public:
void use() override { cout << "ConcreteProduct1 used." << endl; }
};
// 具体产品类2
class ConcreteProduct2 : public Product {
public:
void use() override { cout << "ConcreteProduct2 used." << endl; }
};
// 工厂类
class Factory {
public:
static Product* createProduct(int type) {
switch (type) {
case 1:
return new ConcreteProduct1();
case 2:
return new ConcreteProduct2();
default:
return nullptr;
}
}
};
int main() {
Product* product1 = Factory::createProduct(1);
product1->use(); // 输出 "ConcreteProduct1 used."
Product* product2 = Factory::createProduct(2);
product2->use(); // 输出 "ConcreteProduct2 used."
return 0;
}
工厂方法模式是一种创建型设计模式,它提供了一个接口来创建对象,但是允许子类决定要实例化的类。在工厂方法模式中,创建对象的代码被封装在一个工厂接口中,具体对象的创建被子类实现。这样就能在不修改客户端代码的情况下添加新的产品类型。
工厂方法模式通常包含以下角色:
抽象产品:定义产品的接口,所有具体产品都实现这个接口。
具体产品:实现抽象产品接口,定义具体产品的行为。
抽象工厂:定义创建产品的接口,包含一个或多个工厂方法,用于创建不同类型的产品。
具体工厂:实现抽象工厂接口,包含一个或多个工厂方法,用于创建具体产品的实例。
工厂方法模式的优点是:
可以隐藏产品的创建细节,使客户端代码更加简洁和易于维护。
增加新的产品类型时,只需要添加具体产品和相应的具体工厂类,不需要修改已有的代码,符合开闭原则。
可以将具体产品的创建过程推迟到子类中,实现了抽象工厂模式中的产品族概念。
一个简单的工厂方法模式示例代码如下:
// 抽象产品
class Product {
public:
virtual ~Product() {}
virtual void operation() = 0;
};
// 具体产品A
class ConcreteProductA : public Product {
public:
void operation() override {
cout << "I'm a ConcreteProductA" << endl;
}
};
// 具体产品B
class ConcreteProductB : public Product {
public:
void operation() override {
cout << "I'm a ConcreteProductB" << endl;
}
};
// 抽象工厂
class Factory {
public:
virtual ~Factory() {}
virtual Product* createProduct() = 0;
};
// 具体工厂A
class ConcreteFactoryA : public Factory {
public:
Product* createProduct() override {
return new ConcreteProductA();
}
};
// 具体工厂B
class ConcreteFactoryB : public Factory {
public:
Product* createProduct() override {
return new ConcreteProductB();
}
};
// 客户端
int main() {
Factory* factoryA = new ConcreteFactoryA();
Product* productA = factoryA->createProduct();
productA->operation(); // 输出: I'm a ConcreteProductA
Factory* factoryB = new ConcreteFactoryB();
Product* productB = factoryB->createProduct();
productB->operation(); // 输出: I'm a ConcreteProductB
delete factoryA;
delete productA;
delete factoryB;
delete productB;
return 0;
}