一、 什么是工廠模式
工廠模式（Factory Pattern）是一種創(chuàng)建型設(shè)計模式，它提供了一種創(chuàng)建對象的接口，但是將對象的實例化過程推遲到子類中。工廠模式允許通過調(diào)用一個共同的接口方法來創(chuàng)建不同類型的對象，而無需暴露對象的實例化邏輯。
工廠模式的主要目標是解耦對象的創(chuàng)建和使用，以及提供一種更靈活的方式來管理對象的實例化。通過使用工廠模式，可以輕松添加新類型的對象，而不會影響到已有的代碼。
工廠模式通常涉及以下幾個核心角色：
- 產(chǎn)品（Product）：這是一個抽象類或接口，定義了所創(chuàng)建對象的通用接口。
- 具體產(chǎn)品（Concrete Product）：這些是實現(xiàn)了產(chǎn)品接口的具體類，它們是工廠方法模式的創(chuàng)建目標。
- 工廠（Factory）：這是一個抽象類或接口，定義了創(chuàng)建對象的接口方法。工廠類通常是一個創(chuàng)建具體產(chǎn)品對象的工廠方法。
- 具體工廠（Concrete Factory）：這些是實現(xiàn)了工廠接口的具體類，它們負責實例化具體的產(chǎn)品對象。
工廠模式可以分為三種常見的變體：
- 簡單工廠模式（Simple Factory Pattern）：通過一個共同的工廠類來創(chuàng)建對象，客戶端只需傳遞一個參數(shù)來指定所需的對象類型。雖然不是嚴格意義上的設(shè)計模式，但它是工廠模式的基礎(chǔ)。
- 工廠方法模式（Factory Method Pattern）：定義一個工廠接口，具體的工廠子類負責實現(xiàn)工廠接口并創(chuàng)建對象。每個具體工廠對應(yīng)一個特定的產(chǎn)品。
- 抽象工廠模式（Abstract Factory Pattern）：提供了一種創(chuàng)建一系列相關(guān)或相互依賴對象的接口，而無需指定具體類。適用于創(chuàng)建一組相互關(guān)聯(lián)的產(chǎn)品。
二、簡單工廠模式的代碼樣例
簡單工廠模式（Simple Factory Pattern）雖然不是嚴格的設(shè)計模式，但它是工廠模式的一種基本形式，適用于創(chuàng)建單一類別的對象。在簡單工廠模式中，有一個工廠類負責根據(jù)客戶端的請求創(chuàng)建不同類型的對象。
以下是一個用C++實現(xiàn)簡單工廠模式的示例：
#include <iostream>
// 抽象產(chǎn)品類
class Product {
public:
virtual void operation() = 0;
};
// 具體產(chǎn)品類A
class ConcreteProductA : public Product {
public:
void operation() override {
std::cout << "ConcreteProductA operation." << std::endl;
}
};
// 具體產(chǎn)品類B
class ConcreteProductB : public Product {
public:
void operation() override {
std::cout << "ConcreteProductB operation." << std::endl;
}
};
// 簡單工廠類
class SimpleFactory {
public:
// 根據(jù)傳入的參數(shù)創(chuàng)建不同類型的產(chǎn)品對象
static Product* createProduct(char type) {
if (type == 'A') {
return new ConcreteProductA();
} else if (type == 'B') {
return new ConcreteProductB();
} else {
return nullptr; // 可以拋出異?；蚱渌幚?/span>
}
}
};
int main() {
// 客戶端通過工廠創(chuàng)建產(chǎn)品
Product* productA = SimpleFactory::createProduct('A');
Product* productB = SimpleFactory::createProduct('B');
if (productA) {
productA->operation();
delete productA;
}
if (productB) {
productB->operation();
delete productB;
}
return 0;
}
在這個例子中，我們定義了一個抽象產(chǎn)品類 Product，然后有兩個具體的產(chǎn)品類 ConcreteProductA 和 ConcreteProductB。簡單工廠類 SimpleFactory 有一個靜態(tài)方法 createProduct，根據(jù)傳入的參數(shù)來創(chuàng)建不同類型的產(chǎn)品對象。
雖然簡單工廠模式簡化了對象的實例化，但它的弊端在于如果需要添加新類型的產(chǎn)品，就需要修改工廠類的代碼。因此，當需要支持更多產(chǎn)品類型時，更推薦使用工廠方法模式或抽象工廠模式。
三、工廠方法模式的代碼樣例
工廠方法模式（Factory Method Pattern）是一種創(chuàng)建型設(shè)計模式，它定義了一個用于創(chuàng)建對象的接口，但是將具體的對象實例化推遲到子類中。每個具體的工廠子類負責創(chuàng)建特定類型的對象。這種模式使得客戶端代碼與具體創(chuàng)建對象的代碼分離，實現(xiàn)了松耦合。
以下是一個用C++實現(xiàn)工廠方法模式的示例：
#include <iostream>
// 抽象產(chǎn)品類
class Product {
public:
virtual void operation() = 0;
};
// 具體產(chǎn)品類A
class ConcreteProductA : public Product {
public:
void operation() override {
std::cout << "ConcreteProductA operation." << std::endl;
}
};
// 具體產(chǎn)品類B
class ConcreteProductB : public Product {
public:
void operation() override {
std::cout << "ConcreteProductB operation." << std::endl;
}
};
// 抽象工廠類
class Factory {
public:
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() {
// 客戶端通過具體工廠來創(chuàng)建產(chǎn)品
Factory* factoryA = new ConcreteFactoryA();
Product* productA = factoryA->createProduct();
productA->operation();
delete factoryA;
delete productA;
Factory* factoryB = new ConcreteFactoryB();
Product* productB = factoryB->createProduct();
productB->operation();
delete factoryB;
delete productB;
return 0;
}
在這個例子中，我們定義了一個抽象產(chǎn)品類 Product，然后有兩個具體的產(chǎn)品類 ConcreteProductA 和 ConcreteProductB。抽象工廠類 Factory 定義了一個純虛函數(shù) createProduct，由具體的工廠子類來實現(xiàn)該方法并創(chuàng)建特定類型的產(chǎn)品對象。
客戶端使用具體的工廠類來創(chuàng)建產(chǎn)品，這樣客戶端代碼與具體的產(chǎn)品創(chuàng)建代碼分離，實現(xiàn)了解耦。工廠方法模式允許通過添加新的工廠子類來支持新的產(chǎn)品類型，而無需修改現(xiàn)有的代碼。
四、抽象工廠模式的代碼樣例
抽象工廠模式（Abstract Factory Pattern）是一種創(chuàng)建型設(shè)計模式，它提供一個接口用于創(chuàng)建一系列相關(guān)或相互依賴的對象，而無需指定具體類。抽象工廠模式適用于需要創(chuàng)建一組相互關(guān)聯(lián)的產(chǎn)品的情況，它將一組相關(guān)的工廠類封裝起來。
以下是一個用C++實現(xiàn)抽象工廠模式的示例：
#include <iostream>
// 抽象產(chǎn)品類A
class AbstractProductA {
public:
virtual void operationA() = 0;
};
// 具體產(chǎn)品類A1
class ConcreteProductA1 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ConcreteProductA1 operation." << std::endl;
}
};
// 具體產(chǎn)品類A2
class ConcreteProductA2 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ConcreteProductA2 operation." << std::endl;
}
};
// 抽象產(chǎn)品類B
class AbstractProductB {
public:
virtual void operationB() = 0;
};
// 具體產(chǎn)品類B1
class ConcreteProductB1 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ConcreteProductB1 operation." << std::endl;
}
};
// 具體產(chǎn)品類B2
class ConcreteProductB2 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ConcreteProductB2 operation." << std::endl;
}
};
// 抽象工廠類
class AbstractFactory {
public:
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
// 具體工廠類1
class ConcreteFactory1 : public AbstractFactory {
public:
AbstractProductA* createProductA() override {
return new ConcreteProductA1();
}
AbstractProductB* createProductB() override {
return new ConcreteProductB1();
}
};
// 具體工廠類2
class ConcreteFactory2 : public AbstractFactory {
public:
AbstractProductA* createProductA() override {
return new ConcreteProductA2();
}
AbstractProductB* createProductB() override {
return new ConcreteProductB2();
}
};
int main() {
// 客戶端通過具體工廠來創(chuàng)建一組相關(guān)的產(chǎn)品
AbstractFactory* factory1 = new ConcreteFactory1();
AbstractProductA* productA1 = factory1->createProductA();
AbstractProductB* productB1 = factory1->createProductB();
productA1->operationA();
productB1->operationB();
delete factory1;
delete productA1;
delete productB1;
AbstractFactory* factory2 = new ConcreteFactory2();
AbstractProductA* productA2 = factory2->createProductA();
AbstractProductB* productB2 = factory2->createProductB();
productA2->operationA();
productB2->operationB();
delete factory2;
delete productA2;
delete productB2;
return 0;
}
在這個例子中，我們定義了兩組相關(guān)的產(chǎn)品類：AbstractProductA 和 AbstractProductB，然后分別有兩個具體的產(chǎn)品類。抽象工廠類 AbstractFactory 定義了兩個純虛函數(shù)，分別用于創(chuàng)建 AbstractProductA 和 AbstractProductB 對象。具體的工廠類 ConcreteFactory1 和 ConcreteFactory2 實現(xiàn)了這些方法，并創(chuàng)建特定類型的產(chǎn)品對象。
通過使用抽象工廠模式，客戶端可以通過具體的工廠來創(chuàng)建一組相關(guān)的產(chǎn)品，實現(xiàn)了一種創(chuàng)建一系列相互關(guān)聯(lián)產(chǎn)品的方式。這有助于實現(xiàn)高內(nèi)聚、低耦合的設(shè)計。
五、三種工廠模式之間的關(guān)系
這三種工廠模式（簡單工廠模式、工廠方法模式和抽象工廠模式）都是創(chuàng)建型設(shè)計模式，旨在解決對象的創(chuàng)建問題。它們之間有一些共同點，但也存在一些差異。下面是它們之間的關(guān)系和區(qū)別：
共同點：
- 都關(guān)注對象的創(chuàng)建，封裝了對象的實例化過程，使客戶端代碼與具體創(chuàng)建邏輯分離。
- 都遵循了開閉原則，即可以通過添加新的產(chǎn)品類或工廠類來擴展功能，而無需修改現(xiàn)有代碼。
差異：
- 簡單工廠模式：雖然不是嚴格意義上的設(shè)計模式，但它是工廠模式的基礎(chǔ)。它通過一個共同的工廠類來創(chuàng)建不同類型的對象，客戶端根據(jù)參數(shù)來指定對象類型。適用于創(chuàng)建單一類別的對象。
- 工廠方法模式：定義了一個工廠接口，由具體的工廠子類來實現(xiàn)工廠接口并創(chuàng)建特定類型的產(chǎn)品對象。每個工廠只負責創(chuàng)建一種產(chǎn)品。適用于創(chuàng)建一組相關(guān)的產(chǎn)品，每個產(chǎn)品有一個對應(yīng)的工廠。
- 抽象工廠模式：提供了一種創(chuàng)建一組相關(guān)或相互依賴對象的接口，每個具體的工廠子類負責創(chuàng)建一組相關(guān)產(chǎn)品。適用于創(chuàng)建一組相互關(guān)聯(lián)的產(chǎn)品，每組產(chǎn)品都有一個對應(yīng)的工廠。
適用場景：
- 簡單工廠模式適用于創(chuàng)建簡單的對象，例如基于傳入?yún)?shù)創(chuàng)建對象的情況。
- 工廠方法模式適用于需要創(chuàng)建多種具有相同接口的產(chǎn)品，而且每種產(chǎn)品都有對應(yīng)的工廠。
- 抽象工廠模式適用于創(chuàng)建一組相關(guān)或相互依賴的產(chǎn)品，且每組產(chǎn)品都有對應(yīng)的工廠。
總之，這三種工廠模式都在不同情況下提供了靈活的對象創(chuàng)建機制，可以根據(jù)具體的需求來選擇合適的模式。簡單工廠模式通常是基礎(chǔ)，而工廠方法模式和抽象工廠模式則在更復(fù)雜的場景下提供更大的靈活性。文章來源：http://www.zghlxwxcb.cn/news/detail-682606.html
文章來源地址http://www.zghlxwxcb.cn/news/detail-682606.html
到了這里，關(guān)于設(shè)計模式--工廠模式（Factory Pattern）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
