简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式

简单工厂模式并不是23种设计模式中的，但是在实际的应用中却经常使用。

UML图：

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

　　 在这个模式中， 工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。

　　 不难发现，简单工厂模式的缺点也正体现在其工厂类上， 由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

C++实现：

<pre name="code" class="cpp">//简单工厂模式
#include<iostream>
using namespace std;
class product
{
    public:
        virtual void produce(){cout<<"base product"<<endl;}
        virtual ~product(){}
};
class productA:public product
{
    public:
        void produce(){cout<<"product A"<<endl;}
        ~productA(){}
};
class productB:public product
{
    public:
        void produce(){cout<<"product B"<<endl;}
        ~productB(){}
};
class Factory
{
    public:
        product* make_product(const int&);
};
product* Factory::make_product(const int& type)
{
    product *pd;
    switch(type)
    {
        case 1:
            pd=new productA();
            break;
        case 2:
            pd=new productB();
            break;
        default:
            break;
    }
    return pd;
}
int main()
{
    Factory fty;
    product *pd=fty.make_product(1);
    pd->produce();
    pd=fty.make_product(2);
    pd->produce();
    return 0;
}

工厂方法模式

工厂方法模式是在简单工厂模式的基础上，对“工厂”添加了一个抽象层。将工厂共同的动作抽象出来，作为抽象类，而具体的行为由子类本身去实现，让子类去决定生产什么样的产品。

UML图：

适用场合：

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

1、在设计的初期，就考虑到产品在后期会进行扩展的情况下，可以使用工厂方法模式；

2、产品结构较复杂的情况下，可以使用工厂方法模式；

C++代码实现：

<pre name="code" class="cpp">//工厂方法模式
#include<iostream>
using namespace std;
class product
{
    public:
        virtual void produce(){cout<<"base product"<<endl;}
        virtual ~product(){}
};
class productA:public product
{
    public:
        void produce(){cout<<"product A"<<endl;}
        ~productA(){}
};
class productB:public product
{
    public:
        void produce(){cout<<"product B"<<endl;}
        ~productB(){}
};
class Factory
{
    public:
        virtual product* make_product(){};
};
class FactoryA:public Factory
{
    public:
        product* make_product(){ return new productA(); }
};
class FactoryB:public Factory
{
    public:
        product* make_product(){ return new productB(); }
};
int main()
{
    Factory *fty;
    product *pd;
    fty=new FactoryA();
    pd=fty->make_product();
    pd->produce();
    fty=new FactoryB();
    pd=fty->make_product();
    pd->produce();
    return 0;
}

简单工厂模式

简单工厂模式中，对工厂类的依赖太严重，所有的判断全部放在工厂类中，可扩展性不强。

抽象工厂模式，就是工厂方法模式的扩展和延伸，但是抽象工厂模式，更有一般性和代表性；它具有工厂方法具有的优点，也增加了解决实际问题的能力。

UML图：

如图所示，抽象工厂模式，就好比是两个工厂方法模式的叠加。抽象工厂创建的是一系列相关的对象，其中创建的实现其实就是采用的工厂方法模式。在工厂Factory中的每一个方法，就好比是一条生产线，而生产线实际需要生产什么样的产品，这是由Factory1和Factory2去决定的，这样便延迟了具体子类的实例化；同时集中化了生产线的管理，节省了资源的浪费。

使用场合：

1.希望一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节 时。

2.一个系统有多于一个的产品族，而系统只消费其中某一产品族

本质： 选择产品簇的实现

C++代码：

<pre name="code" class="cpp">//抽象工厂模式
#include<iostream>
using namespace std;
class productA
{
    public:
        virtual void show(){cout<<"productA"<<endl;}
        virtual ~productA(){}
};
class productA_1:public productA
{
    public:
        void show(){cout<<"product A_1"<<endl;}
        ~productA_1(){}
};
class productA_2:public productA
{
    public:
        void show(){cout<<"product A_2"<<endl;}
        ~productA_2(){}
};
class productB
{
    public:
        virtual void show(){cout<<"product B"<<endl;}
        virtual ~productB(){}
};
class productB_1:public productB
{
    public:
        void show(){cout<<"product B_1"<<endl;}
        ~productB_1(){}
};
class productB_2:public productB
{
    public:
        void show(){cout<<"product B_2"<<endl;}
        ~productB_2(){}
};
class Factory
{
    public:
        virtual productA* make_productA(){};
        virtual productB* make_productB(){};
        virtual ~Factory(){}
};
class Factory_1:public Factory
{
    public:
        productA* make_productA()
        {
            return new productA_1;
        }
        productB* make_productB()
        {
            return new productB_1;
        }
        ~Factory_1(){}
};
class Factory_2:public Factory
{
    public:
        productA* make_productA()
        {
            return new productA_2;
        }
        productB* make_productB()
        {
            return new productB_2;
        }
        ~Factory_2(){}
};
int main()
{
    Factory *fty;
    productA *pdA;
    productB *pdB;
    fty=new Factory_1();
    pdA=fty->make_productA();
    pdB=fty->make_productB();
    pdA->show();
    pdB->show();
    fty=new Factory_2();
    pdA=fty->make_productA();
    pdB=fty->make_productB();
    pdA->show();
    pdB->show();
    return 0;
}