工厂模式Factory – 学习HeadFirst设计模式记录

 

简单工厂模式Factory Patten：将创建对象的代码放到一个单独的工厂类中管理。也有人说，简单工厂模式不是一个设计模式，反而比较像是一种编程习惯。

工厂方法模式：定义了一个创建对象的接口，但由子类决定实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

OO设计原则：依赖倒置原则，要依赖抽象，不要依赖具体类。

 

1、提供Pizza原料，使用抽象工厂模式

class PizzaIngredientFactory
{
public:
     virtual  void CreateDough() =  0;
     virtual  void CreateSauce() =  0;
     virtual  void CreateToppings() =  0;
     virtual  void CreateCheese() =  0;
     virtual  void CreateClam() =  0;
};

class NYPizzaIngredientFactory :  public PizzaIngredientFactory
{
public:
     virtual  void CreateDough()   { std::cout<< "     Creating NY dough...  "<<std::endl; };
     virtual  void CreateSauce()   { std::cout<< "     Creating NY souce...  "<<std::endl; };
     virtual  void CreateToppings(){ std::cout<< "     Creating NY toppings...  "<<std::endl; };
     virtual  void CreateCheese()  {};
     virtual  void CreateClam()    {};
};

class ChicagoPizzaIngredientFactory :  public PizzaIngredientFactory
{
public:
     virtual  void CreateDough()   { std::cout<< "     Creating Chicago dough...  "<<std::endl; };
     virtual  void CreateSauce()   { std::cout<< "     Creating Chicago souce...  "<<std::endl; };
     virtual  void CreateToppings(){ std::cout<< "     Creating Chicago toppings...  "<<std::endl; };
     virtual  void CreateCheese()  {};
     virtual  void CreateClam()    {};
};

 

2、定义 NYStylePizza 和 ChicagoStylePizza

  
class Pizza
{
public:
     void Prepare()
    {
        std::cout<< " 1.Prepareing  "<<_name.c_str()<<std::endl;
        _ingredientFactory->CreateDough();     /* 抽象工厂创建原料 */
        _ingredientFactory->CreateSauce();     /* 抽象工厂创建原料 */
        _ingredientFactory->CreateToppings();  /* 抽象工厂创建原料 */
    }
     void Bake()
    {
        std::cout<< " 2.Bake for 25 minutes at 350 degress. "<<std::endl;
    }
     void Cut()
    {
        std::cout<< " 3.Cutting the pizza into diagonal slices. "<<std::endl;
    }
     void Box()
    {
        std::cout<< " 4.Place pizza in offical PizzaStore box. "<<std::endl;
    }

    std:: string GetName()
    {
         return _name;
    }

protected:
    std:: string _name;
    std:: string _dough;  /* 面团 */
    std:: string _sauce;  /* 调味汁 */
    std:: string _toppings;  /* 糕点上的装饰配料 */
    PizzaIngredientFactory *_ingredientFactory;
};

class NYStyleCheesePizza :  public Pizza
{
public:
    NYStyleCheesePizza(PizzaIngredientFactory *ingredientFactory)
    {
        _name =  " NY Style Sauce and Cheese Pizza ";
        _ingredientFactory = ingredientFactory;
    }
};
class NYStyleClamPizza :  public Pizza  /* 捞蛤Pizza */
{
public:
    NYStyleClamPizza(PizzaIngredientFactory *ingredientFactory)
    {
        _name =  " NY Style Sauce and Clam Pizza ";
        _ingredientFactory = ingredientFactory;
    }
};
class ChicagoStyleCheesePizza :  public Pizza
{
public:
    ChicagoStyleCheesePizza(PizzaIngredientFactory *ingredientFactory)
    {
        _name =  " Chicago Style Sauce and Cheese Pizza ";
        _ingredientFactory = ingredientFactory;
    }
};
class ChicagoStyleClamPizza :  public Pizza  /* 辣香肠Pizza */
{
public:
    ChicagoStyleClamPizza(PizzaIngredientFactory *ingredientFactory)
    {
        _name =  " Chicago Style Sauce and Clam Pizza ";
        _ingredientFactory = ingredientFactory;
    }
};

 

3、Pizza店，创建pizza制作pizza，使用工厂方法模式

class PizzaStore
{
public:

    Pizza* OrderPizza(std:: string type)
    {
        Pizza *pizza;
        pizza = CreatePizza(type);

        pizza->Prepare();
        pizza->Bake();
        pizza->Cut();
        pizza->Box();

         return pizza;
    }

     virtual Pizza* CreatePizza(std::string type) = 0; /*工厂方法：把创建对象交给子类，由子类决定创建什么Pizza*/
};
/* 工厂方法类 */
class NYStylePizzaStore :  public PizzaStore
{
public:
    NYStylePizzaStore()
    {
        _ingredientFactory =  new NYPizzaIngredientFactory();
    }

     virtual Pizza* CreatePizza(std::string type)
    {
         if ( 0 == type.compare( " cheese "))
        {
             return  new NYStyleCheesePizza(_ingredientFactory);
        }
         else  if ( 0 == type.compare( " clam "))
        {
             return  new NYStyleClamPizza(_ingredientFactory);
        }
         // else if (0 == type.compare("veggie"))
         // else if (0 == type.compare("pepperoni"))
         else  return NULL;
    }
private:
    PizzaIngredientFactory *_ingredientFactory;
};
/* 工厂方法类 */
class ChicagoStylePizzaStore :  public PizzaStore
{
public:
    ChicagoStylePizzaStore()
    {
        _ingredientFactory =  new ChicagoPizzaIngredientFactory();
    }

     virtual Pizza* CreatePizza(std::string type)
    {
         if ( 0 == type.compare( " cheese "))
        {
             return  new ChicagoStyleCheesePizza(_ingredientFactory);
        }
         else  if ( 0 == type.compare( " clam "))
        {
             return  new ChicagoStyleClamPizza(_ingredientFactory);
        }
         // else if (0 == type.compare("veggie"))
         // else if (0 == type.compare("pepperoni"))
         else  return NULL;
    }
private:
    PizzaIngredientFactory *_ingredientFactory;
};

 

4、测试代码

  
int main()
{
    std::cout<< " Factory Patten "<<std::endl<<std::endl;

    PizzaStore *nyStore =  new NYStylePizzaStore();
    Pizza *pizza = nyStore->OrderPizza( " cheese ");
    std::cout<< " Jack ordered a  "<<pizza->GetName().c_str()<< " . "<<std::endl<<std::endl;

    PizzaStore *chicagoStore =  new ChicagoStylePizzaStore();
    Pizza *pizza2 = chicagoStore->OrderPizza( " clam ");
    std::cout<< " Joel ordered a  "<<pizza2->GetName().c_str()<< " . "<<std::endl<<std::endl;

     return  0;

}