《headfirst设计模式》读书笔记4-工厂模式

1. 简单工厂

简单工厂其实就相当于封装创建对象地代码
工厂：处理创建对象地细节。

简单工厂其实不是一个设计模式，反而比较像一种编程习惯。

2. 工厂方法模式

2.1 加盟披萨店

在简单工厂能制作披萨的前提下，每个地区的披萨店制作的披萨不一样，所以需要添加对披萨的分类创建

2.2 工厂方法

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

2.3 部分源码

2.3.1 PizzaStore.h

#include "Pizza.h"
class PizzaStore{
public:
    virtual Pizza *createPizza(string item)=0;
    Pizza *orderPizza(string type);
    virtual ~PizzaStore();
};

2.3.2 PizzaStore.cpp

#include "PizzaStore.h"
#include <iostream>
using std::cout;
using std::endl;
Pizza *PizzaStore::orderPizza(std::string type)
{
    Pizza *pizza=createPizza(type);
    cout<<"--- Making a " + pizza->getName() + " ---"<<endl;
    pizza->prepare();
    pizza->bake();
    pizza->cut();
    pizza->box();

    return pizza;
}

PizzaStore::~PizzaStore()
{

}

2.3.3 NYPizzaStore.h

#include "PizzaStore.h"
class NYPizzaStore:public PizzaStore{
public:
    virtual Pizza *createPizza(string item)override final;
    virtual ~NYPizzaStore();
};

2.3.4 NYPizzaStore.cpp

#include "NYPizzaStore.h"
#include "NYStyleCheesePizza.h"
#include "NYStyleClamPizza.h"
#include "NYStylePepperoniPizza.h"
#include "NYStyleVeggiePizza.h"
Pizza *NYPizzaStore::createPizza(std::string item)
{
    if (item=="cheese") {
        return new NYStyleCheesePizza();
    } else if (item=="veggie") {
        return new NYStyleVeggiePizza();
    } else if (item=="clam") {
        return new NYStyleClamPizza();
    } else if (item=="pepperoni") {
        return new NYStylePepperoniPizza();
    } else return NULL;
}

NYPizzaStore::~NYPizzaStore()
{

}

3. 抽象工厂

3.1 原料家族

在制作披萨时，当每个地区使用的原料不同时，针对这种情况应该如何应对？

3.2 定义抽象工厂模式

抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类
抽象工厂定义了一个接口，所有的具体工厂都必须实现此接口，这个接口包含一组方法用来生产产品

3.3 部分源码

3.3.1 PizzaIngredientFactory.h

#include "Dough.h"
#include "Sauce.h"
#include "Cheese.h"
#include "Veggies.h"
#include "Pepperoni.h"
#include "Clams.h"
#include "AllIngredients.h"
#include <vector>
using std::vector;
class PizzaIngredientFactory{
public:
    virtual Dough *createDough()=0;
    virtual Sauce *createSauce()=0;
    virtual Cheese *createCheese()=0;
    virtual vector<Veggies*> createVeggies()=0;
    virtual Pepperoni *createPepperoni()=0;
    virtual Clams *createClam()=0;
    virtual ~PizzaIngredientFactory(){};
};

3.3.2 NYPizzaIngredientFactory.h

#include "PizzaIngredientFactory.h"
class NYPizzaIngredientFactory:public PizzaIngredientFactory{
public:
    virtual Dough *createDough()override final;
    virtual Sauce *createSauce()override final;
    virtual Cheese *createCheese()override final;
    virtual vector<Veggies*> createVeggies()override final;
    virtual Pepperoni *createPepperoni()override final;
    virtual Clams *createClam()override final;
    virtual ~NYPizzaIngredientFactory();
};

3.3.3 VeggiePizza.h

#include "Pizza.h"
#include "PizzaIngredientFactory.h"
class VeggiePizza:public Pizza{
public:
    VeggiePizza(PizzaIngredientFactory *ingredientFactory);
    virtual void prepare()override final;
    virtual ~VeggiePizza();
private:
    PizzaIngredientFactory *ingredientFactory;
};

3.3.4 VeggiePizza.cpp

#include "VeggiePizza.h"

VeggiePizza::VeggiePizza(PizzaIngredientFactory *ingredientFactory)
{
    this->ingredientFactory=ingredientFactory;
}

void VeggiePizza::prepare()
{
    cout<<"Preparing "+name<<endl;
    dough=ingredientFactory->createDough();
    sauce=ingredientFactory->createSauce();
    cheese=ingredientFactory->createCheese();
    veggies=ingredientFactory->createVeggies();
}

VeggiePizza::~VeggiePizza()
{

}

4. 工厂方法和抽象工厂的区别

工厂方法就是创建一个抽象方法创建对象，然后让子类来决定创建的具体对象，抽象工厂就是用工厂方法创建一组对象组成一个创建的接口，然后将其对象传给其它对象进行组合使用来创建一组对象。

5. 总结

1.针对接口编程，可以隔离掉以后系统可能发生的一大堆改变。为什么呢？如果代码是针对接口而写，那么通过多态，它可以与任何新类实现该接口。
2.在设计模式中，所谓的“实现一个接口”并“不一定”表示“写一个类，并利用implement关键词来实现某个java接口”。“实现一个接口”泛指“实现某个超类型（可以是类或接口）的某种方法”。
3.

4.