三种工厂模式

转自 https://www.cnblogs.com/cxjchen/p/3143633.html

简单工厂模式

模式动机

考虑一个简单的软件应用场景，一个软件系统可以提供多个外观不同的按钮（如圆形按钮，矩形按钮，菱形按钮等），这些按钮都源自同一个基类，不过在继承基类后不同的子类修改了部分属性从而使得它们可以呈现不同的外观，如果我们希望使用这些按钮时，不需要知道这些具体按钮类的名字，只需要知道表示该按钮类的一个参数，并提供一个调用方便的方法，

模式定义

简单工厂模式，又称静态工厂方法模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

简单工厂模式的优点

• 工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅”消费“产品；简单工厂模式通过这种做法实现了对责任的分割，它提供了专门的工厂类用于创建对象
• 客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量
• 通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

简单工厂模式的缺点

• 由于工厂类集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都要受到影响
• 使用简单工厂模式将会增加系统中类的个数，在一定程度上增加了系统的复杂度和理解难度
• 系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，在产品类型较多时，有可能造成工厂逻辑过于复杂，不利于系统的扩展和维护

适用环境

• 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
• 客户端只知道传入工厂类的参数，对于如何创建对象并不关心，客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

实现代码

AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H
#define _ABSTRACTPRODUCT_H

#include <stdio.h>

class AbstractProduct{
public:
	AbstractProduct();
    virtual ~AbstractProduct();

public:
    virtual void operation() = 0;
};

class ProductA : public AbstarctProduct
{
public:
    ProductA();
    virtual ~ProductA();
    
public:
    void operation();
};

class ProductB : public AbstractProduct
{
public:
    ProductB();
    ~ProductB();
    
public:
    void operation();
};

#endif

AbstractProduct.cpp

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){}
AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}
ProductA::~ProductA(){}
void ProductA::operation()
{
	fprintf(stderr, "ProductA operation!\n");
}

ProductB::ProductB(){}
ProductB::~ProductB(){}
void ProductB::operation()
{
	fprintf(stderr, "ProductB operation!\n");
}

SimpleFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTORY_H_

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProduct* createProduct(int type) = 0;
};

class SimpleFactory : public AbstractFactory
{
public:
    SimpleFactory();
    ~SimpleFactory();
    
public:
    AbstractProduct* createProduct(int type);
};

#endif

SimpleFactory.cpp

#include "SimpleFactory.h"

AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}

SimpleFactory::SimpleFactory(){}
SimpleFactory::~SimpleFactory(){}

AbstractProduct* SimpleFactory::createProduct(int type)
{
	AbstractProduct* temp = nullptr;
    switch(type)
    {
        case 1:
            temp = new ProductA();
            break;
        case 2:
            temp = new ProductB();
            break;
        default:
            break;
    }
    return temp;
}

client.cpp

#include "SimpleFactory.h"

int main()
{
	AbstractFactory* factory = new SimpleFactory();
    AbstractProduct* product = factory->createProduct(1);
    product->operation();
    delete product;
    product = nullptr;
    
    product = factory->createProduct(2);
    product->operation();
    delete product;
    product = nullptr;
    
    return 0;
}

工厂方法模式

模式动机

现在对系统进行修改，不再设计一个工厂类来同一负责所有产品的创建，而是将具体产品的创建过程交给专门的工厂子类去完成。我们先定义一个抽象的工厂类，再定义具体的工厂类，来生产产品A，产品B，产品C等。它们实现在抽象工厂类中定义的方法。这种抽象化的结果使这种结构可以在不修改具体工厂类的情况下引进新的产品，如果出现新的产品类型，只需要为这种新类型的产品创建一个具体的工厂类就可以获得该产品的实例，更加符合”开放原则“。

模式定义

工厂方法模式又称工厂模式，也叫虚拟构造器模式或者多态模式，它属于创建型模式。在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。

模式分析

工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了面向对象的多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建工作交给子类去做。这个核心类仅仅负责给出具体工厂必须实现的接口，而不负责哪一个产品类被实例化这种细节，这使得工厂方法模式可以允许系统在不修改工厂角色的情况下引进新产品。

工厂方法模式的优点

• 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无须知道具体产品类的类名。
• 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，是因为所有的具体工厂类都具有同一抽象父类。
• 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只需要添加具体工厂和具体产品就可以了。这样，系统的可扩展性也就变的非常好，完全符合”开闭原则“

工厂方法模式的缺点

• 在添加新产品时，需要编写新的具体产品类，而且还要提高与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
• 考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度

适用环境

• 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类
• 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心哪一个工厂子类创建产品子类，需要时在动态指定，可将具体工厂类的类名存储在配置文件或数据库中

实现代码

AbstractProduct.h

#ifndef _ABSTRACTPRODUCT_H_
#define _ABSTRACTPRODUCT_H_

#include <stdio.h>

class AbstractProduct
{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    
public:
    virtual void operation() = 0;
};

class ProductA : public AbstractProduct
{
public:
    ProductA();
    virtual ~ProductA();
    
public:
	virtual void operation() = 0;
};

class ProductB : public AbstractProduct
{
public:
    ProductB();
    virtual ~ProductB();
    
public:
    virtual void operation() = 0;
};

#endif

AbstractProduct.cpp

#include "AbstractProduct.h"

AbstractProduct::AbstractProduct(){}
AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}
ProductA::~ProductA(){}
void ProductA::operation()
{
    fprintf(stderr, "productA operation!\n");
}

ProductB::ProductB(){}
ProductB::~ProductB(){}
void ProductB::operation()
{
    fprintf(stderr, "productB operation!\n");
}

AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTORY_H_

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
  
public:
    virtual AbstractProduct* createProduct() = 0;
};

class FactoryA : public AbstractFactory
{
public:
    FactoryA();
    ~Factory();
    
public:
    AbstractProduct* createProduct();
};

class FactoryB : public AbstractFactory
{
public:
    FactoryB();
    ~FactoryB();
    
public:
    AbstractProduct* createProduct();
};

#endif

AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}

FactoryA::FactoryA(){}
FactoryA::~FactoryA(){}
AbstractProduct* FactoryA::createProduct()
{
    AbstractProduct* temp = nullptr;
    temp = new ProductA();
    return temp;
}

FactoryB::FactoryB(){}
FactoryB::~FactoryB(){}
AbstractProduct* FactoryB::createProduct()
{
    AbstractProduct* temp = nullptr;
    temp = new ProductB();
    return temp;
}

client.cpp

#include "AbstractFactory.h"

int main()
{
    AbstractFactory* factory = new FactoryA();
    AbstractProduct* product = factory->createProduct();
    product->operation();
    delete product;
    product = nullptr;
    delete factory;
    factory = nullptr;
    
    factory = new FactoryB();
    product = factory->createProduct();
    product->operation();
    delete product;
    product = nullptr;
    delete factory;
    factory = nullptr;
    
    return 0;
}

抽象工厂模式

模式动机

• 在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。
  • 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机，海信电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类
  • 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机，海尔电冰箱，海尔电视及位于电视机产品等级结构中，海尔电冰箱位于电冰箱等级结构中
• 当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式
• 抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态
• 抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单，有效率。

模式定义

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

抽象工厂模式优点

• 抽象工程模式隔离了具体类的生成，使得客户并不需要知道什么被创建，由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合”开闭原则“

抽象工厂模式缺点

• 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）

适用环境

• 一个系统不应当依赖于产品类是如何被创建，组合和表达的细节，这对于所有类型的工厂模式都是重要的
• 系统中有多余一个的产品族，而每次只是用其中某一个产品族
• 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来
• 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

实现代码

AbstractProductA.h

#ifndef _ABSTRACTPRODUCTA_H_
#define _ABSTRACTPRODUCTA_H_

#include <stdio.h>

class AbstractProductA
{
public:
    AbstractProductA();
    virtual ~AbstractProductA();
    
public:
    virtual void operationA() = 0;
};

class productA_1 : public AbstractProductA
{
public:
    ProductA_1();
    virtual ~ProductA_1();

public:
	void operationA();
};

class ProductA_2 : public AbstractProductA
{
public:
    ProductA_2();
    virtual ~ProductA_2();
    
public:
	void operationA();
};

#endif

AbstractProductA.cpp

#include "AbstractProductA.h"

AbstractProductA::AbstractProductA(){}
AbstractProductA::~AbstractProductA(){}

ProductA_1::ProductA_1(){}
ProductA_1::~ProductA_1(){}
void ProductA_1::operationA()
{
    fprintf(stderr, "producta_1 operation!\n");
}

ProductA_2::ProductA_2(){}
ProductA_2::~ProductA_2(){}
void ProductA_2::operationA()
{
    fprintf(stderr, "productA_2 operation!\n");
}

AbstractProductB.h

#ifndef _ABSTRACTPRODUCTB_H_
#define _ABSTRACTPRODUCTB_H_

#include <stdio.h>

class AbstractProductB
{
public:
    AbstractProductB();
    virtual ~AbstractProductB();
    
public:
    virtual void operationB() = 0;
};

class productB_1 : public AbstractProductB
{
public:
    ProductB_1();
    virtual ~ProductB_1();

public:
	void operationB();
};

class ProductB_2 : public AbstractProductB
{
public:
    ProductB_2();
    virtual ~ProductB_2();
    
public:
	void operationB();
};

#endif

AbstractProductB.cpp

#include "AbstractProductB.h"

AbstractProductB::AbstractProductB(){}
AbstractProductB::~AbstractProductB(){}

ProductB_1::ProductB_1(){}
ProductB_1::~ProductB_1(){}
void ProductB_1::operationB()
{
    fprintf(stderr, "productB_1 operation!\n");
}

ProductB_2::ProductB_2(){}
ProductB_2::~ProductB_2(){}
void ProductB_2::operationB()
{
    fprintf(stderr, "productB_2 operation!\n");
}

AbstractFactory.h

#ifndef _SIMPLEFACTORY_H_
#define _SIMPLEFACTORY_H_

#include <stdio.h>
#include "AbstractProductA.h"
#include "AbstractProductB.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    
public:
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

class Factory1 : public AbstractFactory
{
public:
    Factory1();
    ~Factory1();

public:
	AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

class Factory2 : public AbstractFactory
{
public:
    Factory2();
    ~Factory2();

public:
    AbstractProductA* createProductA();
    AbstractProductB* createProductB();
};

#endif

AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(){}
AbstractFactory::~AbstractFactory(){}

Factory1::Factory(){}
Factory1::~Factory(){}
AbstractProductA* Factory1::createProductA()
{
    AbstractProductA* temp = nullptr;
    temp = new ProductA_1();
    return temp;
}
AbstractProductB* Factory1::createProductB()
{
    AbstractProductB* temp = nullptr;
    temp = new ProductB_1();
    return temp;
}

Factory2::Factory(){}
Factory2::~Factory(){}
AbstractProductA* Factory2::createProductA()
{
    AbstractProductA* temp = nullptr;
    temp = new ProductA_2();
    return temp;
}
AbstractProductB* Factory2::createProductB()
{
    AbstractProductB* temp = nullptr;
    temp = new ProductB_2();
    return temp;
}

client.cpp

#include "AbstractFactory.h"

int main()
{
	AbstractFactory* factory = new Factory1();
    AbstractProduct* productA = factory->createProductA();
    AbstractProduct* productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = nullptr;
    delete productA;
    productA = nullptr;
    delete productB;
    productB = nullptr;
    
    factory = new Factory2();
    productA = factory->createProductA();
    productB = factory->createProductB();
    productA->operationA();
    productB->operationB();
    
    delete factory;
    factory = nullptr;
    delete productA;
    productA = nullptr;
    delete productB;
    productB = nullptr;
    
   	return 0;
}