第五章 工厂模式

1. 简单工厂模式

1.1 设计图示

1.2 设计说明

• 简单工厂模式核心： Product* SimpleFactory::create(string type)
  即：根据输入条件 type ，SimpleFactory构建不同的对象。

	    virtual Product* SimpleFactory::create(string type)
	    {
	        if(type=="ProductA")
	        return new ConcreteProductA;
	        else if (type == "ProductB")
	        return new ConcreteProductB;
	        else
	        return NULL;
	    }

• 缺点 增加ConcreteProduct，需要同时修改create函数

1.3 示例代码

#include <iostream>
using namespace std;

class Product
{
public:
  virtual void method (void) = 0;
};
class ConcreteProductA:public Product
{
public:
  void method ()
  {
    cout << "A" << endl;
  }

};

class ConcreteProductB:public Product
{
public:
  void method ()
  {
    cout << "B" << endl;
  }

};
class SimpleFactory
{
public:
  Product* create (string type)
  {
    if (type == "A")
      return new ConcreteProductA;
    else if (type == "B")
      return new ConcreteProductB;
    else
      return NULL;
  }
};

int
main ()
{
SimpleFactory factoryObj;
Product* Aobj = factoryObj.create("A");
Product* Bobj = factoryObj.create("B");
Aobj->method();
Bobj->method();

  return 0;
}

2. 工厂模式

2.1 设计图示

• 与简单工厂的区别：
  例子含有两个简单工厂，ConcreteFactory1 + ConcreteFactory2
  不同工厂对相同产品的工艺可能不同。例如2.2一节举披萨店为例

• 缺点
  设计者考虑增加一种Product类型，也需要修改createProduct源码

2.2 披萨工厂

	#include <iostream>
	using namespace std;
	
	class Pizza
	{
	public:
	  virtual ~ Pizza ()
	  {
	  }
	  virtual void prepare () = 0;
	  virtual void bake () = 0;
	  virtual void cut () = 0;
	  virtual void package () = 0;
	};
	
	class NYStyleCheesePizza:public Pizza
	{
	public:
	    void prepare() {cout << "prepare NYStyleCheesePizza " << endl;}
	    void bake() {cout << "bake NYStyleCheesePizza " << endl;}
	    void cut() {cout << "cut NYStyleCheesePizza " << endl;}
	    void package() {cout << "package NYStyleCheesePizza " << endl;}
	};
	class ChicagoStyleCheesePizze:public Pizza
	{
	public:
	    void prepare() {cout << "prepare ChicagoStyleCheesePizze " << endl;}
	    void bake() {cout << "bake ChicagoStyleCheesePizze " << endl;}
	    void cut() {cout << "cut ChicagoStyleCheesePizze " << endl;}
	    void package() {cout << "package ChicagoStyleCheesePizze " << endl;}
	};
	class NYStyleVeggiePizza:public Pizza
	{
	public:
	    void prepare() {cout << "prepare NYStyleVeggiePizza " << endl;}
	    void bake() {cout << "bake NYStyleVeggiePizza " << endl;}
	    void cut() {cout << "cut NYStyleVeggiePizza " << endl;}
	    void package() {cout << "package NYStyleVeggiePizza " << endl;}
	};
	class ChicagoStyleVeggiePizza:public Pizza
	{
	public:
	    void prepare() {cout << "prepare ChicagoStyleVeggiePizza " << endl;}
	    void bake() {cout << "bake ChicagoStyleVeggiePizza " << endl;}
	    void cut() {cout << "cut ChicagoStyleVeggiePizza " << endl;}
	    void package() {cout << "package ChicagoStyleVeggiePizza " << endl;}
	};
	
	class PizzaStore
	{
	public:
	    virtual int ordePizza(string type)
	    {
	        Pizza* PizzaObj = createPizza(type);
	        if(NULL == PizzaObj)
	        {
	            return -1;
	        }
	        PizzaObj->prepare();
	        PizzaObj->bake();
	        PizzaObj->cut();
	        PizzaObj->package();
	        return 0;
	    }
	private:
	    virtual Pizza* createPizza(string type)
	    {
	        return NULL;
	    }
	};
	
	class ChicagoPizzaStore:public PizzaStore
	{
	    virtual Pizza* createPizza(string type)
	    {
	        if(type=="cheese")
	        return new ChicagoStyleCheesePizze;
	        else if (type == "veggie")
	        return new ChicagoStyleVeggiePizza;
	        else
	        return NULL;
	    }
	};
	
	class NYPizzaStore:public PizzaStore
	{
	    virtual Pizza* createPizza(string type)
	    {
	        if(type=="cheese")
	        return new NYStyleCheesePizza;
	        else if (type == "veggie")
	        return new NYStyleVeggiePizza;
	        else
	        return NULL;
	    }    
	};
	
	
	int
	main ()
	{
	  ChicagoPizzaStore chicagoStoreObj;
	  NYPizzaStore nvStoreObj;
	  
	  chicagoStoreObj.ordePizza("cheese");
	  chicagoStoreObj.ordePizza("veggie");
	  
	  nvStoreObj.ordePizza("cheese");
	  nvStoreObj.ordePizza("veggie");
	  return 0;
	}

2.3 工厂模式 VS 简单工厂模式

工厂模式支持多家工厂，每家工厂对相同产品的工艺不同而已

3. 抽象工厂

3.1 设计图示

3.2 抽象工厂 VS 工厂模式

抽象工厂增加了一个create接口，这样一个工厂可以生产若干彼此无关的产品类别