工厂模式进阶复习#

看了多遍的工厂模式，老是忘记不同模式有什么区别，本文重点说明一下工厂模式的三种方式（简单工厂模式，工厂方法模式，抽象工厂模式）的区别

1.简单工厂模式

简单工厂模式通过Factory判断不同的类型来实现不同product的创建

typedef enum ProductTypeTag
{
    TypeA,
    TypeB,
    TypeC
}PRODUCTTYPE;

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

class ProductA : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductA"<<endl;
    }
};

class ProductB : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductB"<<endl;
    }
};

class ProductC : public Product
{
public:
    void Show()
    {
        cout<<"I'm ProductC"<<endl;
    }
};

class Factory
{
public:
    Product* CreateProduct(PRODUCTTYPE type)
    {
        switch (type)
        {
        case TypeA:
            return new ProductA();

        case TypeB:
            return new ProductB();

        case TypeC:
            return new ProductC();

        default:
            return NULL;
        }
    }
};

调用代码：

Factory *ProductFactory = new Factory();
Product *productObjA = ProductFactory->CreateProduct(TypeA);
productObjA->Show();

Product *productObjB = ProductFactory->CreateProduct(TypeB);
productObjB->Show();

Product *productObjC = ProductFactory->CreateProduct(TypeC);
productObjC->Show();

2.工厂方法模式

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

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

class ProductA : public Product
{
public:
    void Show()
    {
        cout<< "I'm ProductA"<<endl;
    }
};

class ProductB : public Product
{
public:
    void Show()
    {
        cout<< "I'm ProductB"<<endl;
    }
};

class Factory
{
public:
    virtual Product *CreateProduct() = 0;
};

class FactoryA : public Factory
{
public:
    Product *CreateProduct()
    {
        return new ProductA ();
    }
};

class FactoryB : public Factory
{
public:
    Product *CreateProduct()
    {
        return new ProductB ();
    }
};

调用代码：

Factory *factoryA = new FactoryA ();
Product *productA = factoryA->CreateProduct();
productA->Show();

Factory *factoryB = new FactoryB ();
Product *productB = factoryB->CreateProduct();
productB->Show();

3.抽象工厂模式

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

// Product A
class ProductA
{
public:
    virtual void Show() = 0;
};

class ProductA1 : public ProductA
{
public:
    void Show()
    {
        cout<<"I'm ProductA1"<<endl;
    }
};

class ProductA2 : public ProductA
{
public:
    void Show()
    {
        cout<<"I'm ProductA2"<<endl;
    }
};

// Product B
class ProductB
{
public:
    virtual void Show() = 0;
};

class ProductB1 : public ProductB
{
public:
    void Show()
    {
        cout<<"I'm ProductB1"<<endl;
    }
};

class ProductB2 : public ProductB
{
public:
    void Show()
    {
        cout<<"I'm ProductB2"<<endl;
    }
};

class Factory
{
public:
    virtual Product *CreateProductA() = 0;
            virtual Product *CreateProductB() = 0;
};

class Factory1 : public Factory
{
public:
    Product *CreateProductA()
    {
        return new ProductA ();
    }
    Product *CreateProductB()
    {
        return new ProductB ();
    }
};

class Factory2 : public Factory
{
public:
    Product *CreateProductA()
    {
        return new ProductA ();
    }
    Product *CreateProductB()
    {
        return new ProductB ();
    }
};

调用代码：

Factory *factoryObj1 = new Factory1();
ProductA *productObjA1 = factoryObj1->CreateProductA();
ProductB *productObjB1 = factoryObj1->CreateProductB();

productObjA1->Show();
productObjB1->Show();

Factory *factoryObj2 = new Factory2();
ProductA *productObjA2 = factoryObj2->CreateProductA();
ProductB *productObjB2 = factoryObj2->CreateProductB();

productObjA2->Show();
productObjB2->Show();