重中之重：工厂模式

高层次掌握、彻底掌握工厂模式

建立一个简单比萨工厂 -->
public   class  SimplePizzaFactory  ... {
    public Pizza createPizza(String type) ...{
        Pizza pizza = null;
        if (type.equals("cheese"))
        ...{
            pizza = new CheesePizza();
        }
        else if (type.equals("pepperoni"))
        ...{
            pizza = new PepperoniPizza();
        }
        else if (type.equals("clam"))
        ...{
            pizza = new ClamPizza();
        }
        else if (type.equals("veggie"))
        ...{
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

重建PizzaStore类 -->
public   class  PizzaStore  ... {
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory) ...{
        this.factory = factroy;
    }
    public Pizza orderPizza(String type) ...{
        Pizza pizza;
        pizza = factory.createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}
=========================================================================
以上是简单工厂（一种编程习惯）
=========================================================================

（加盟比萨店）给比萨店使用的框架 -->
public   abstract   class  PizzaStore  ... {
    public Pizza orderPizza(String type) ...{
        Pizza pizza;

        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);
}

允许子类做决定（2nd动手开店） -->
public  Pizza createPizza(String type)  ... {
    if (type.equals("cheese"))
    ...{
        pizza = new ChicagoStyleCheesePizza();
    }
    else if (type.equals("pepperoni"))
    ...{
        pizza = new ChicagoStylePepperoniPizza();
    }
    else if (type.equals("clam"))
    ...{
        pizza = new ChicagoStyleClamPizza();
    }
    else if (type.equals("veggie"))
    ...{
        pizza = new ChicagoStyleVeggiePizza();
    }
}
2nd
public   class  NYPizzaStore  extends  PizzaStore  ... {
    Pizza createPizza(String item) ...{
        if (item.equals("cheese"))
        ...{
            pizza = new NYStyleCheesePizza();
        }
        else if (item.equals("pepperoni"))
        ...{
            pizza = new NYStylePepperoniPizza();
        }
        else if (item.equals("clam"))
        ...{
            pizza = new NYStyleClamPizza();
        }
        else if (item.equals("veggie"))
        ...{
            pizza = new NYStyleVeggiePizza();
        }
        else return null;
    }
}

声明一个工厂方法 -->
public   abstract   class  PizzaStore  ... {
    public Pizza orderPizza(String type) ...{
        Pizza pizza;

        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);
    //其他的方法
}

比萨本身 -->
public   abstract   class  Pizza  ... {
    String name;
    String dough;
    String sauce;
    ArrayList toppings = new ArrayList();

    void prepare() ...{
        System.out.println("Preparing " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding topping: ");
        for (int i=0; i<toppings.size(); i++)
        ...{
            System.out.println("   " + toppings.get(i));
        }
    }
    void bake() ...{
        System.out.println("Bake for 25 minutes at 350");
    }
    void cut() ...{
        System.out.println("Cutting the pizza into diagonal slices");
    }
    void box() ...{
        System.out.println("Place pizza in offical PizzaStore box");
    }
    public String getName() ...{
        return name;
    }
}

public   class  NYStyleCheesePizza  extends  Pizza  ... {
    public NYStyleCheesePizza() ...{
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
    }
}

public   class  ChicagoStyleCheesePizza  extends  Pizza  ... {
    public ChicagoStyleCheesePizza() ...{
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
    }

    void cut() ...{
        System.out.println("Cutting the pizza into square slices");
    }
}

==>
public   class  PizzaTestDrive  ... {
    public static void main(String[] args) ...{
        PizzaStore nyStore = new NYPizzaStore();
        PizzaStore chicagoStore = new ChicagoPizzaStore();

        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Ethan ordered a " + pizza.getName() + " ");
        Pizza pizza = chicagoStore.orderPizza("cheese");
        System.out.println("Joel ordered a " + pizza.getName() + " ");
    }
}
=========================================================================
以上是工厂方法模式（Factory Method Pattern）
工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
    工厂方法让类把实例化推迟到子类。
=========================================================================
依赖倒置原则（Dependency Inversion Principle）
OO设计原则：要依赖抽象，不要依赖具体类。
帮助避免在OO设计中违反依赖导致原则的指导方针：
变量不可以持有具体类的引用；不要让类派生自具体类；不要覆盖基类中已实现的方法。

建造原料工厂 -->
public   interface  PizzaIngredientFactory  ... {
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClam();
}

创建纽约原料工厂 -->
public   class  NYPizzaIngredientFactory  implements  PizzaIngredientFactory  ... {
    public Dough createDough() ...{
        return new ThinCrustDough();
    }
    public Sauce createSauce() ...{
        return new MarinaraSauce();
    }
    public Cheese createCheese() ...{
        return new ReggianoCheese();
    }
    public Veggies[] createVeggies() ...{
        Veggies veggies[] = ...{new Garlic(), new Onion(), new Mushroom(), new RedPepper()};
        return veggies;
    }
    public Pepperoni createPepperoni() ...{
        return new SlicedPepperoni();
    }
    public Clams createClam() ...{
        return new FreshClams();
    }
}

重做比萨 -->
public   abstract   class  Pizza  ... {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

    abstract void prepare();

    void bake() ...{
        System.out.println("Bake for 25 minutes at 350");
    }
    void cut() ...{
        System.out.println("Cutting the pizza into diagonal slices");
    }
    void box() ...{
        System.out.println("Place pizza in official PizzaStore box");
    }
    void setName(String name) ...{
        this.name = name;
    }
    String getName() ...{
        return name;
    }
    public String toString() ...{
        //这里是打印比萨的代码
    }
}

继续重做比萨 -->
public   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();
    }
}

public   class  ClamPizza  extends  Pizza  ... {
    PIzzaIngredientFactory ingredientFactory;
    public ClamPizza(PizzaIngredientFactory ingredientFactory) ...{
        this.ingredientFactory = ingredientFactory;
    }
    void prepare() ...{
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        clam = ingredientFactory.createClam();
    }
}

再回到比萨店 -->
public   class  NYPizzaStore  extends  PizzaStore  ... {
    protected 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("pepperoni"))
        ...{
            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("New York Style Pepperoni Pizza");
        }
        else if (item.equals("clam"))
        ...{
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
        }
        else if (item.equals("veggie"))
        ...{
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
        }
        return pizza;
    }
}

PizzaStore nyPizzaStore  =   new  NYPizzaStore();

nyPizzaStore.orderPizza( " cheese " );

Pizza pizza  =  createPizza( " cheese " );

Pizza pizza  =   new  CheesePizza(nyIngredientFactory);

void  prepare()  ... {
    dough = factory.createDough();
    sauce = factory.createSauce();
    cheese = factory.createCheese();
}
================================================================================
抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
================================================================================