什么是工厂模式

工厂模式(Factory Pattern)属于创建型模式，它提供了一种创建对象的最佳方式。定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂模式将目的将创建对象的具体过程屏蔽隔离起来，从而达到更高的灵活性。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式分为以下三类：

• 简单工厂模式（Simple Factory)
• 工厂方法模式（Factory Method）
• 抽象工厂模式（Abstract Factory）

《设计模式》一书中将工厂模式分为两类：工厂方法模式与抽象工厂模式。简单工厂模式被看工厂方法模式的一种特例，两者归为一类。 也就是GOF提出的23种设计模式并不包含简单工厂模式。这三种模式逐步抽象。

简单工厂模式

在简单工厂模式中，创建实例的方法通常为静态方法。因此简单工厂模式又叫作静态工厂方法模式(Static Factory Method Pattern)。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

简单工厂模式的核心是定义一个创建对象的接口，将对象的创建和本身的业务逻辑分离，降低系统的耦合度，使得两个修改起来相对容易些，当以后实现改变时，只需要修改工厂类即可。

简单工厂模式中的角色

• 具体工厂：负责实现创建所有实例的内部逻辑。它提供了创建产品的方法，调用者通过该方法来获取产品。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

• 抽象产品角色：定义了产品的规范，描述了产品的主要特性和功能。简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

• 具体产品角色：是实现或者继承抽象产品的子类，也是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

UML类图

代码

抽象产品接口：

class IProduct{
public:
    virtual void func() = 0;
};

具体产品1和2：

class Product1:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 1 n";
    }
};

class Product2:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 2 n";
    }
};

工厂类：

class Factory{
public:
    static IProduct* createProduct(int n){
        switch (n){
            case 1:return new Product1;  
            case 2:return new Product2;
        }
        return nullptr;
    }
};

主函数：

int main(){
    IProduct* p1 = Factory::createProduct(1);
    IProduct* p2 = Factory::createProduct(2);
    p1->func();
    p2->func();

	delete p1, p2;
}

输出内容：

I'm product 1 
I'm product 2

简单工厂模式的缺点在于每次添加新产品就需要修改工厂类。在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展维护，并且工厂类集中了所有产品创建逻辑，一旦不能正常工作，整个系统都要受到影响。违背了“开闭原则”。

为了解决简单工厂模式的问题，出现了工厂方法模式。

工厂方法模式

工厂方法模式是对简单工厂模式的进一步抽象化，并定义一个创建对象的接口。其好处是可以使系统在不修改原来代码的情况下引进新的产品。每增加新产品，只需增加该产品以及对应的具体实现工厂类，由具体工厂类决定要实例化的产品是哪个，将对象的创建与实例化延迟到子类，这样工厂的设计就符合“开闭原则”了，扩展时不必去修改原来的代码。在使用时，用于只需知道产品对应的具体工厂，关注具体的创建过程，甚至不需要知道具体产品类的类名，当我们选择哪个具体工厂时，就已经决定了实际创建的产品是哪个了。

但缺点在于，每增加一个产品都需要增加一个具体产品类和实现工厂类，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

工厂方法模式中的角色

• 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
• 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

UML类图

代码

抽象产品接口：

class IProduct{
public:
    virtual void func() = 0;
};

具体产品：

class Product1:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 1 n";
    }
};

class Product2:public IProduct{
public:
    void func(){
        std::cout<<"I'm product 2 n";
    }
};

抽象工厂接口：

class IFactory{
public:
    virtual IProduct* createProduct() = 0;
};

具体工厂：

class Product1Factory:public IFactory{
public:
    IProduct* createProduct(){
        return new Product1;  
    }
};
class Product2Factory:public IFactory{
public:
    IProduct* createProduct(){
        return new Product2;  
    }
};

主函数：

int main(){
    IFactory* fac = nullptr;
    
    fac = new Product1Factory();
    IProduct* p1 = fac->createProduct();
    
    fac = new Product2Factory();
    IProduct* p2 = fac->createProduct();
    
    p1->func();
    p2->func();

	delete fac, p1, p2;
}

输出内容：

I'm product 1 
I'm product 2

抽象工厂模式

在工厂方法模式中，我们使用一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。

在介绍抽象工厂模式前，我们先厘清两个概念：

• 产品等级结构：产品等级结构指的是产品的继承结构，例如下图果园1，果园2，果园3出产的苹果属于苹果，也可以说是继承了苹果抽象类，那么这个苹果抽象类和他的子类就构成了一个产品等级结构。
• 产品族：产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，果园1出产苹果、橙子、香蕉。它们就属于同一产品族。

抽象工厂模式主要用于创建相关对象的族，一个工厂就是一个产品族。通过抽象工厂模式，我们能够保证客户端始终只使用同一个产品族中的对象。并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类。所有的具体工厂都实现了抽象工厂中定义的公共接口。

但该模式的缺点在于添加新的行为时比较麻烦，如果需要添加一个新产品族对象时，需要更改接口及其下所有子类。

抽象工厂模式中的角色

抽象工厂：提供了创建产品的接口，包含多个创建产品的方法，可以创建多个不同等级的产品。所有的具体工厂都必须实现此接口。

具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。用于生产不同产品族，要创建一个产品，用户只需使用其中一个工厂进行获取，完全不需要实例化任何产品对象。

抽象产品：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。是一个产品家族，每一个具体工厂都能够生产一整组产品。

具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

UML类图

代码

抽象产品接口：

class IProductA{
public:
    virtual void func() = 0;
};

class IProductB{
public:
    virtual void func() = 0;
};

具体产品类实现：

class ProductA1:public IProductA{
public:
    void func(){
        std::cout<<"I'm product A1 n";
    }
};

class ProductA2:public IProductA{
public:
    void func(){
        std::cout<<"I'm product A2 n";
    }
};

class ProductB1:public IProductB{
public:
    void func(){
        std::cout<<"I'm product B1 n";
    }
};

class ProductB2:public IProductB{
public:
    void func(){
        std::cout<<"I'm product B2 n";
    }
};

抽象工厂接口：

class IFactory{
public:
    virtual IProductA* createProductA() = 0;
    virtual IProductB* createProductB() = 0;
};

具体工厂：

class Product1Factory:public IFactory{
public:
    IProductA* createProductA(){
        return new ProductA1;
    }
    IProductB* createProductB(){
        return new ProductB1;
    }
};

class Product2Factory:public IFactory{
public:
    IProductA* createProductA(){
        return new ProductA2;
    }
    IProductB* createProductB(){
        return new ProductB2;
    }
};

主函数

int main(){
    IFactory* fac1 = new Product1Factory();
    IFactory* fac2 = new Product2Factory();
    
    IProductA* pa1 = fac1->createProductA();
    IProductA* pa2 = fac2->createProductA();
    IProductB* pb1 = fac1->createProductB();
    IProductB* pb2 = fac2->createProductB();

    pa1->func();
    pa2->func();
    pb1->func();
    pb2->func();

    delete fac1, fac2, pa1, pa2, pb1, pb2;
}

输出结果：

I'm product A1
I'm product A2
I'm product B1
I'm product B2

最后

以上就是灵巧哈密瓜为你收集整理的[设计模式] 工厂模式什么是工厂模式简单工厂模式工厂方法模式抽象工厂模式的全部内容，希望文章能够帮你解决[设计模式] 工厂模式什么是工厂模式简单工厂模式工厂方法模式抽象工厂模式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。