工厂模式

1.定义了一个创建对象的接口，工厂方法创建一个框架，让子类决定如何实现

2.代码：

C++

//factory c++
#include <iostream>
#include <string>
using namespace std;

//面团 
class Dough{
public:
    virtual string getIngredientInfo() = 0;
};
//薄饼
class ThinCrustDough : public Dough {
public:
    string getIngredientInfo() {
        return "Thin Crust Dough";
    }
};
//厚的
class ThickCrustDough : public Dough {
public:
    string getIngredientInfo(){
        return "ThickCrust style extra thick crust dough";
    }
};

//酱料
class Sauce {
public:
    virtual string getIngredientInfo() = 0;
};
//意大利红酱
class MarinaraSauce : public Sauce {
public:
    string getIngredientInfo(){
        return "Marinara Sauce";
    }
};
//番茄酱
class PlumTomatoSauce : public Sauce {
public:
    string getIngredientInfo() {
        return "Tomato sauce with plum tomatoes";
    }
};

//奶酪
class Cheese {
public:
    virtual string getIngredientInfo() = 0;
};
//莫泽雷勒干酪
class MozzarellaCheese : public Cheese {
public:
    string getIngredientInfo(){
        return "Shredded Mozzarella";
    }
};
//巴马干酪
class ReggianoCheese : public Cheese {
public:
    string getIngredientInfo(){
        return "Reggiano Cheese";
    }
};

//原材料
class PizzaIngredientFactory{
public:
    virtual Dough  * createDough()  = 0;
    virtual Sauce  * createSauce()  = 0;
    virtual Cheese * createCheese() = 0;
    //...
};

//生产 纽约口味
class NYPizzaIngredientFactory : public PizzaIngredientFactory{
public:
    Dough* createDough(){
        return new ThinCrustDough();
    }
    Sauce* createSauce(){
        return new MarinaraSauce();
    }
    Cheese* createCheese(){
        return new ReggianoCheese();
    }
};

//生产 芝加哥口味
class ChicagoPizzaIngredientFactory : public PizzaIngredientFactory{
public: 
    Dough* createDough(){
        return new ThickCrustDough();
    }
    Sauce* createSauce(){
        return new PlumTomatoSauce();
    }
    Cheese* createCheese(){
        return new MozzarellaCheese();
    }
};

//披萨
class Pizza{
public:
    virtual void prepare() = 0;           //统一原材料配给
    
    void bake()                { cout<<"Bake for 25 minutes..."<<endl; }
    void box()                 { cout<<"box done"<<endl; }
    
    void   setName(string name){ this->name = name; }
    string getName()           { return this->name; }
    string getIngredientInfo() {
        string str = "---- ";
               str += this->name;
               str += " ----\n";
        if (dough) {
            str += dough->getIngredientInfo() + "\n\r";
        }
        if (sauce) {
            str += sauce->getIngredientInfo() + "\n\r";
        }
        if (cheese) {
            str += cheese->getIngredientInfo() + "\n\r";
        }
        return str;
    }

    string  name;
    Dough * dough;  //饼
    Sauce * sauce;  //酱料
    Cheese* cheese; //奶酪
};

//生产奶酪披萨
class CheesePizza : public Pizza{
public:
    CheesePizza(PizzaIngredientFactory* factory): m_ingredientFactory(factory){}
    void prepare(){
        cout<<"Preparing "<<this->getName()<<endl;
        dough  = m_ingredientFactory->createDough();
        sauce  = m_ingredientFactory->createSauce();
        cheese = m_ingredientFactory->createCheese(); 
    }
private:
    PizzaIngredientFactory* m_ingredientFactory;
};

//披萨店
class PizzaStore{
public:
    virtual Pizza* createPizza(string type) = 0; //不同地域口味的披萨
    Pizza* orderPizza(string type)              //统一品牌流程
    {
        Pizza* pizza = createPizza(type);
        pizza->prepare();
        pizza->bake();
        pizza->box();
        return pizza;
    }
};

//纽约的加盟店
class NYPizzaStore : public PizzaStore{
public:
    Pizza* createPizza(string type){
        Pizza *pizza = NULL;
        PizzaIngredientFactory* ingredientFactory = new NYPizzaIngredientFactory();
        if("cheese" == type){
            pizza = new CheesePizza(ingredientFactory);
            pizza->setName("New York Style Cheese Pizza");
        }
        else if("veggie" == type){
            //...
        }
        return pizza;
    }
};

//芝加哥的
class ChicagoPizzaStore : public PizzaStore{
public:
    Pizza* createPizza(string type){
        Pizza *pizza = NULL;
        PizzaIngredientFactory* ingredientFactory = new ChicagoPizzaIngredientFactory();
        if("cheese" == type){
            pizza = new CheesePizza(ingredientFactory);
            pizza->setName("Chicago Style Cheese Pizza");
        }
        else if("veggie" == type){
            //...
        }
        return pizza;
    }
};

//点餐
int main()
{
    //1
    PizzaStore *nyStore = new NYPizzaStore();
    Pizza      *pizza   = nyStore->orderPizza("cheese");
    cout<<"order a " <<pizza->getIngredientInfo()<<endl;
    //2
    PizzaStore *chStore = new ChicagoPizzaStore();
                pizza   = chStore->orderPizza("cheese");
    cout<<"order a " <<pizza->getIngredientInfo();
    return 0;
}

  Java

//factory java

//PizzaStore
abstract class PizzaStore{
    public final Pizza orderPizza(String type){ //order same
        Pizza pizza;
        pizza = createPizza(type);              //
        pizza.prepare();
        pizza.bake();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);    //taste different in other area
}

//New York Pizza Store
class NYPizzaStore extends PizzaStore{
    Pizza createPizza(String item){
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        if(item.equals("cheese")){
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
        }
        else if(item.equals("veggie")){
            //...
        }
        return pizza;
    }
}
//Chicago Pizza Store
class ChicagoPizzaStore extends PizzaStore{
    Pizza createPizza(String item){
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new ChicagoPizzaIngredientFactory();
        if(item.equals("cheese")){
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("Chicago Style Cheese Pizza");
        }
        else if(item.equals("veggie")){
            //...
        }
        return pizza;
    }
}

//Pizza
abstract class Pizza{
    String name;
    Dough  dough;
    Sauce  sauce;
    Cheese cheese;
    //ArrayList<String> toppings = new ArrayList<String>();
    
    abstract void prepare();   //
    void bake(){
        System.out.println("Bake for 25 minutes...");
    }
    //...
    void box(){
        System.out.println("box done");
    }
    void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public String toString() {
        StringBuffer result = new StringBuffer();
        result.append("---- " + name + " ----\n");
        if (dough != null) {
            result.append(dough);
            result.append("\n");
        }
        if (sauce != null) {
            result.append(sauce);
            result.append("\n");
        }
        if (cheese != null) {
            result.append(cheese);
            result.append("\n");
        }
        return result.toString();
    }
}

//CheesePizza
//do not need class NYStyleCheesePizza and class ChicagoStyleCheesePizza
class CheesePizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;
    public CheesePizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory = ingredientFactory;
    }
    void prepare(){
        System.out.println("Preparing " + name);
        dough  = ingredientFactory.createDough();
        sauce  = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese(); 
    }
}

//ingredient factory
interface PizzaIngredientFactory{
    public Dough  createDough();
    public Sauce  createSauce();
    public Cheese createCheese();
    //...
}

//NYPizzaIngredientFactory
class NYPizzaIngredientFactory implements PizzaIngredientFactory{
    public Dough createDough(){
        return new ThinCrustDough();
    }
    public Sauce createSauce(){
        return new MarinaraSauce();
    }
    public Cheese createCheese(){
        return new ReggianoCheese();
    }
} 

//ChicagoPizzaIngredientFactory
class ChicagoPizzaIngredientFactory implements PizzaIngredientFactory{
    public Dough createDough(){
        return new ThickCrustDough();
    }
    public Sauce createSauce(){
        return new PlumTomatoSauce();
    }
    public Cheese createCheese(){
        return new MozzarellaCheese();
    }
}

//Dough
interface Dough {
    public String toString();
}
class ThinCrustDough implements Dough {
    public String toString() {
        return "Thin Crust Dough";
    }
}
class ThickCrustDough implements Dough {
    public String toString() {
        return "ThickCrust style extra thick crust dough";
    }
}

//Sauce
interface Sauce {
    public String toString();
}
class MarinaraSauce implements Sauce {
    public String toString() {
        return "Marinara Sauce";
    }
}
class PlumTomatoSauce implements Sauce {
    public String toString() {
        return "Tomato sauce with plum tomatoes";
    }
}

//Cheese
interface Cheese {
    public String toString();
}
class MozzarellaCheese implements Cheese {

    public String toString() {
        return "Shredded Mozzarella";
    }
}
class ReggianoCheese implements Cheese {

    public String toString() {
        return "Reggiano Cheese";
    }
}

//SimpleFactory
public class SimpleFactory{
    public static void main(String[] args){
        //1
        PizzaStore nyStore = new NYPizzaStore();
        Pizza      pizza   = nyStore.orderPizza("cheese");
        System.out.println("order a " + pizza);
        
        //2
        PizzaStore chStore = new ChicagoPizzaStore();
                   pizza   = chStore.orderPizza("cheese");
        System.out.println("order a " + pizza);
    }
}

  3.杂记：

（1）“实现一个接口” 并不一定 表示写一个类并利用 implements 实现某个java接口；

         “实现一个接口” 泛指实现某个超类型（类或接口）

（2）一个好的加盟店 不需要 管他在披萨中放了什么东西（允许厨师创意）

（3）参数可以利用enum等防止写错

（4）“依赖倒置原则”（Pependency Inversion Principle）

           依赖抽象，不依赖具体类，听起来像“针对接口..不针对实现”；

           意思是：高层组件 和 低层组件都依赖抽象，而不是高层依赖低层，低层能变成了实现;(披萨各地口味不同，奶酪披萨各地口味再由配料组成)

          “倒置”：不是从顶部（披萨店）开始然后往下到具体类， 否则披萨店将全部依赖这些具体类；

                      而是从Pizza开始（别从顶端开始）然后想想看能抽象化些什么

                      依赖一个工厂 将具体类从披萨店取出，

                      倒置了一个商店依赖具体类的设计，也倒置了思考方式

（5）尽量，非必须：

                    变量不可以持有具体类的引用

                    不让类派生自具体类

                    不覆盖基类已实现方法

（6）如果一个类可能改变，可以采用一些好的技巧（例如工厂）来封装改变

  (7)  “抽象工厂” 和 “工厂方法” 是两个东西：

         抽象工厂：提供创建一个产品族的抽象类型（Pizza类：能生产各种披萨）；

         工厂方法：创建一个产品（PizzaStore的实现为工厂方法：纽约店，芝加哥店）；