简单工厂与工厂模式(Factory)

简单工厂并不是一个“真正的“模式，可以把它当作一种编程习惯。它的最大优点在于工厂类中包含必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖

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

要点：
1.所有的工厂都是用来封闭对象的创建
2.简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦
3.工厂方法使用继承，把对象的创建委托给子类，子类实现工厂方法来创建对象
4.所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合
5.工厂方法允许类将实例化延迟到子类进行
6.依赖倒置原则，指导我们避免依赖具体类型，而要尽量依赖抽象

设计原则：依赖倒置：依赖抽象，不要依赖具体类
1.变量不可以持有具体类的引用
2.不要让类派生自具体类
3.不要覆盖基类中已实现的方法


Pizza.h

#ifndef PIZZA_H
#define PIZZA_H
#include<iostream>
using namespace std;
enum PizzaType{
    CHEESEPIZZA,
    VEGGIEPIZZA,
    CLAMPIZZA,
    PEPPERONIPIZZA
};

class Pizza{
public:
    virtual void prepare(){
        cout << "prepare..." << endl;
    }
    void bake(){
        cout << "bake..." << endl;
    }
    void cut(){
        cout << "cut..." << endl;
    }
    void box(){
        cout << "box..." << endl;
    }
};

class CheesePizza:public Pizza{};
class NYStyleCheesePizza:public Pizza{};

class VeggiePizza:public Pizza{};
class NYStyleVeggiePizza:public Pizza{};

class ClamPizza:public Pizza{};
class NYStyleClamPizza:public Pizza{};

class PepperonPizza:public Pizza{};
class NYStylePepperonPizza:public Pizza{};
#endif // PIZZA_H

PizzaStore.h

#ifndef PIZZASTORE_H
#define PIZZASTORE_H
#include"Pizza.h"
#include"SimplePizzaFactory.h"
class PizzaStore{
public:
    explicit PizzaStore(SimplePizzaFactory* spf=NULL){
        mFactory = spf;
    }
    //工厂方法
    virtual Pizza* createPizza(PizzaType pt)=0;

    //由于pizza是抽象的，orderPizza并不知道哪些实例加进来，也就是解耦
    Pizza* orderPizza(PizzaType pt){
        Pizza* pizza;
        //pizza = mFactory->cratePizza(pt);
        pizza = createPizza(pt);
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();
        return pizza;
    }
private:
    SimplePizzaFactory* mFactory;
};

class NYPizzaStore:public PizzaStore{
public:
    Pizza* createPizza(PizzaType pt){
        switch(pt){
        case CHEESEPIZZA:
            return new NYStyleCheesePizza;
            break;
        case VEGGIEPIZZA:
            return new NYStyleVeggiePizza;
            break;
        case PEPPERONIPIZZA:
            return new NYStylePepperonPizza;
            break;
        case CLAMPIZZA:
            return new NYStyleClamPizza;
            break;
        default:
            return NULL;
            break;
        }
    }
};

#endif // PIZZASTORE_H

SimplePizzaFactory.h

#ifndef SIMPLEPIZZAFACTORY_H
#define SIMPLEPIZZAFACTORY_H

#include"Pizza.h"
#include<stdlib.h>
//简单工厂
class SimplePizzaFactory{
public:
    Pizza* cratePizza(PizzaType pt){
        switch(pt){
        case CHEESEPIZZA:
            return new CheesePizza;
            break;
        case VEGGIEPIZZA:
            return new VeggiePizza;
            break;
        case PEPPERONIPIZZA:
            return new PepperonPizza;
            break;
        case CLAMPIZZA:
            return new ClamPizza;
            break;
        default:
            return NULL;
            break;
        }
    }
};

class NYPizzaFactory:public SimplePizzaFactory{
public:
    Pizza* createPizza(PizzaType pt){
        switch(pt){
        case CHEESEPIZZA:
            return new NYStyleCheesePizza;
            break;
        case VEGGIEPIZZA:
            return new NYStyleVeggiePizza;
            break;
        case PEPPERONIPIZZA:
            return new NYStylePepperonPizza;
            break;
        case CLAMPIZZA:
            return new NYStyleClamPizza;
            break;
        default:
            return NULL;
            break;
        }
    }
};

#endif // SIMPLEPIZZAFACTORY_H

main.cpp

#include"PizzaStore.h"

int main(){
    PizzaStore *store = new NYPizzaStore();
    store->orderPizza(CHEESEPIZZA);
}


prepare...
bake...
cut...
box...