设计模式之工厂

1、简单工厂模式

主要作用是封装对象的创建，把对象的创建和操作过程分离，用于批量管理对象的创建过程，便于程序的维护和扩展。
简单工厂是工厂模式最简单的一种实现，对于不同产品的创建定义一个工厂类，将产品的类型作为参数传入到工厂的创建函数，根据类型分支选择不同的产品构造函数。

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

class Product        //产品抽象基类
{
	public:
		virtual void show() = 0;
};

class ProductA : public Product   //产品A
{
	public:
		void show()
		{
			cout<<"productA"<<endl;
		}
};
class ProductB : public Product   //产品B
{
	public:
		void show()
		{
			cout<<"productB"<<endl;
		}
};
class ProductC : public Product  // 产品C
{
	public:
		void show()
		{
			cout<<"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;
        	}
    	}
}

2、工厂方法模式

工厂方法模式在简单工厂模式的基础上增加对工厂的基类抽象，不同的产品创建采用不同的工厂创建。多个工厂多个产品，FactoryA专心负责生产ProductA

该模式相对于简单工厂模式的优势在于：便于后期产品种类的扩展。

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

class Product {//产品抽象基类
public:
    virtual void Show() = 0;
};

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

class ProductB : public Product {
public:
    void Show() {
        cout<<"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();
    }
};

3、抽象工厂模式

• 工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；
• 而抽象工厂方法适用于产品种类结构多的场合，就是当具有多个抽象产品类型的时候。
• 抽象工厂模式更适合实际情况，受生产线所限，让低端工厂生产不同种类的低端产品，高端工厂生产不同种类的高端产品。

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

class ProductA1 : public ProductA {//A类低端产品
public:
    void Show() {
        cout<<"I'm ProductA1"<<endl;
    }
};

class ProductA2 : public ProductA {//A类高端产品
public:
    void Show() {
        cout<<"I'm ProductA2"<<endl;
    }
};

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

class ProductB1 : public ProductB {//B类低端产品
public:
    void Show()
    {
        cout<<"I'm ProductB1"<<endl;
    }
};

class ProductB2 : public ProductB { //B类高端产品
public:
    void Show() {
        cout<<"I'm ProductB2"<<endl;
    }
};
 
class Factory {
public:
    virtual ProductA *CreateProductA() = 0;
    virtual ProductB *CreateProductB() = 0;
};
 
class Factory1 : public Factory { //1号工厂用于生产低端产品
public:
    ProductA *CreateProductA() {
        return new ProductA1();
    }
 
    ProductB *CreateProductB() {
        return new ProductB1();
    }
};
 
class Factory2 : public Factory { //2号工厂用于生产高端产品
    ProductA *CreateProductA() {
        return new ProductA2();
    }
 
    ProductB *CreateProductB() {
        return new ProductB2();
    }
};