简单工厂模式、工厂方法模式和抽象工厂模式-设计模式学习

1、简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

工厂（Creator）角色

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

抽象产品（Product）角色

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品（Concrete Product）角色

是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。



优点

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

缺点

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

这些缺点在工厂方法模式中得到了一定的克服。

UML类图

//简单工厂模式
#include <iostream>

using namespace std;

class Product
{
public:
    virtual void show() = 0;
};

class Product1 : public Product
{
public:
    virtual void show()
    {
        cout<<"I am Product1"<<endl;
    }
};
class Product2 : public Product
{
public:
    virtual void show()
    {
        cout<<"I am Product2"<<endl;
    }
};

class Factory
{
public:
    Product *create(int n)
    {
        switch(n)
        {
        case 1:
            return new Product1;
        case 2:
            return new Product2;
        default:
            cout<<"I dont't know"<<endl;
            return NULL;
        }
    }
};

int main(void)
{
    Factory fac;
    Product *p1 = fac.create(1);
    Product *p2 = fac.create(2);

    p1->show();
    p2->show();

    delete p1;
    delete p2;

    return 0;
}

2、工厂方法模式

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。



抽象工厂(Creator)角色

是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

具体工厂(Concrete Creator)角色

这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与ubeCreator。

抽象产品(Product)角色

工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。

具体产品(Concrete Product)角色

这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。



UML类图

//工厂方法模式
#include <iostream>

using namespace std;

class Product
{
public:
    virtual void show() = 0;
};

class Product1 : public Product
{
public:
    virtual void show()
    {
        cout<<"I am Product1"<<endl;
    }
};
class Product2 : public Product
{
public:
    virtual void show()
    {
        cout<<"I am Product2"<<endl;
    }
};

class IFactory
{
public:
    virtual Product *create() = 0;
};

class Product1Factory : public IFactory
{
public:
    virtual Product *create()
    {
        return new Product1;
    }
};

class Product2Factory : public IFactory
{
public:
    virtual Product *create()
    {
        return new Product2;
    }
};

int main(void)
{
    IFactory *fac1 = new Product1Factory;
    Product *p1 = fac1->create();

    p1->show();

    delete p1;
    delete fac1;

    return 0;
}

3、抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据LSP原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。



UML类图



产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的，形成一个二维的坐标系，水平坐标是产品等级结构，纵坐标是产品族。

当有多个不同的等级结构的产品时，如果使用工厂方法模式就势必要使用多个独立的工厂等级结构来对付这些产品的等级结构。如果这些产品等级结构是平行的，会导致多个平行的工厂等级结构。

抽象工厂模式使用同一个工厂等级结构负责这些不同产品等级结构产品对象的创建。

对于每一个产品族，都有一个具体工厂。而每一个具体工厂创建属于同一个产品族，但是分属于不同等级结构的产品。

通过引进抽象工厂模式，可以处理具有相同（或者相似）等级结构的多个产品族中的产品对象的创建问题。

由于每个具体工厂角色都需要负责两个不同等级结构的产品对象的创建，因此每个工厂角色都需要提供两个工厂方法，分别用于创建两个等级结构的产品。既然每个具体工厂角色都需要实现这两个工厂方法，所以具有一般性，不妨抽象出来，移动到抽象工厂角色中加以声明。

//抽象工厂模式
#include <iostream>

using namespace std;

class ProductA
{
public:
    virtual void show() = 0;
};

class ProductB
{
public:
    virtual void show() = 0;
};

class ProductA_1 : public ProductA
{
public:
    virtual void show()
    {
        cout<<"I am ProductA_1"<<endl;
    }
};

class ProductA_2 : public ProductA
{
public:
    virtual void show()
    {
        cout<<"I am ProductA_2"<<endl;
    }
};

class ProductB_1 : public ProductB
{
public:
    virtual void show()
    {
        cout<<"I am ProductB_1"<<endl;
    }
};

class ProductB_2 : public ProductB
{
public:
    virtual void show()
    {
        cout<<"I am ProductB_2"<<endl;
    }
};

class IFactory
{
public:
    virtual ProductA *createA() = 0;
    virtual ProductB *createB() = 0;
};

class Factory1 : public IFactory
{
public:
    virtual ProductA *createA()
    {
        return new ProductA_1;
    }
    virtual ProductB *createB()
    {
        return new ProductB_1;
    }
};

class Factory2 : public IFactory
{
public:
    virtual ProductA *createA()
    {
        return new ProductA_2;
    }
    virtual ProductB *createB()
    {
        return new ProductB_2;
    }
};
int main(void)
{
    IFactory *p1ifac = new Factory1;
    IFactory *p2ifac = new Factory2;

    ProductA *pa1 = p1ifac->createA();
    ProductB *pb2 = p2ifac->createB();

    pa1->show();
    pb2->show();

    delete pa1;
    delete pb2;
    delete p1ifac;
    delete p2ifac;

    return 0;
}

抽象工厂模式与工厂模式区别：

工厂方法模式：一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

参考资料：

1、简单工厂模式-百度百科

2、工厂方法模式-百度百科

3、抽象工厂模式-百度百科

4、《大话设计模式》的讲解工厂模式章节