制造对象，不仅只有使用new操作符。实例化不应该总是公开进行，因为经常会导致耦合问题。

01例子

假设你有一个披萨店，身为披萨店的主人，代码可能是这样：

Pizza orderPizza(){
//为了让系统有弹性，我们很希望这是一个抽象类或接口。但如果这样，这些类或接口就无法直接实例化。
        Pizza pizza =new Pizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
}

需要更多披萨类型时：

Pizza orderPizza(String type){
        Pizza pizza ;
        if(type.equals("cheese")){
               pizza=new CheesePizza();
        }else if(type.equals("greek")){
               pizza=new GreekPizza();
        }else if(type.equals("pepperoni")){
               pizza=new PepperoniPizza();
        }
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

缺点：如果要增加或者删除某个type，需要对这份代码进行修改。
关于哪个具体类被实例化才是搞乱orderPizza()方法的祸首：
它无法让orderPizza()对修改关闭；但是，现在我们已经知道哪些会改变，哪些不会改变，该是封装的时候了。

02简单工厂

建立简单工厂

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类

依赖工厂来创建pizza

public class PizzaStore{
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory){
        this.factory=factory;
    }
    public Pizza orderPizza(String type){
        Pizza pizza;

        pizza=factory.createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

类图

简单工厂不是设计模式，是一种编程习惯！

03工厂方法

加盟披萨店

如果利用SimplePizzaFactory，写出三种不同的工厂，分别是
NYPizzaFactory，ChicagoPizzaFactory，CaliforniaPizzaFactory，各地加盟店都有适合的工厂可以使用，这是一种做法。

NYPizzaFactory nyFactory=new NYPizzaFactory();//创建纽约风味pizza的工厂
PizzaStore nyStore=new PizzaStore(nyFactory);//创建pizzastore
nyFactory.orderPizza("Veggie");//制作pizza，得到纽约风味的；

缺点：不能质量控制；目的：只想创建pizza不同，其他操作相同；

框架

02简单工厂中，在SimplePizzaFactory前，把制作pizza绑到了store，失去了弹性。【需要】：创建框架，把加盟店和pizza创建绑定在一起，但允许保持弹性

有个做法可让披萨制作轰动局限于PizzaStore类，而同时又能让这些加盟店依然可以自由地制作该区域的风味。
把createPizza()方法放回到PizzaStore中，不过要把它设置成“抽象方法”，然后为每个区域风味创建一个PizzaStore的子类。

public abstract class PizzaStore(){
    public Pizza orderPizza(String type){
        Pizza pizza;

        pizza=createPizza(type);//从工厂对象移回pizzastore；【不是factory.createPizza()】
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    public abstract Pizza createPizza(String type);//把工厂对象移到这个方法中
    //作为抽象方法，为每个区域风味创建一个pizzastore子类
}

子类：

orderPizza()方法在抽象的pizzastore中定义，所以，该方法不知道哪个子类实际运行代码并制作pizza；【即不知道哪个实际的具体类【解耦了】】

实现

加盟店只需要继承pizzastore，并提供自己的pizza风味的creatPizza()方法。

纽约风味店：

class NYPizzaStore extends PizzaStore{
    Pizza createPizza(String type){
         if(type.equals("cheese")){
               pizza=new NYStyleCheesePizza();//创建具体类
        }else if(type.equals("pepperoni")){
               pizza=new NYStylePepperoniPizza();
        }else if(type.equals("clam")){
               pizza=new NYStyleClamPizza();
        }else if(type.equals("veggie")){
               pizza=new NYStyleVeggiePizza();
        }
    }
}

工厂方法（以上框架）

对pizzastore类做一些转换，从由一个对象处理具体类的实例化，到由一个子类集合来承担责任。

public abstract class PizzaStore(){
    public Pizza orderPizza(String type){
        Pizza pizza;

        pizza=createPizza(type);//从工厂对象移回pizzastore；【不是factory.createPizza()】
       //pizzastore的子类在creatpizza()中处理对象的实例化
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    public abstract Pizza createPizza(String type);//把工厂对象移到这个方法中
    //作为抽象方法，为每个区域风味创建一个pizzastore子类
    //实例化pizza的责任被转到了方法中（该方法扮演工厂的角色）
}

Pizza类

public abstract class Pizza{
    String name;
    String dough;
    String sauce;
    ArrayList toppings =new ArrayList();

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

Pizza的一些具体子类

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 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()+"\n")
    }
}

工厂方法模式

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

工厂方法模式能够封装具体类型的实例化，抽象的Creator提供了一个创建对象的方法的接口，在抽象的Creator中，任何其他实现的方法，都可能使用到这个工厂方法所制造出来的产品，但只有子类真正实现这个工厂方法并创建产品。

例子类图：

工厂方法是封装的关键

平行视角：平行的类层级

04依赖倒置原则

对象依赖

当你直接实例化一个对象时，就是在依赖它的具体类，返回前页看看这个依赖性很高的比萨店例子，它由披萨店类来创建所有的披萨对象，而不是委托给工厂。

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

依赖倒置原则更强调抽象。说明高层组件不能依赖底层组件，而且，不管高层或底层组件，都应该依赖抽象。
PizzaStore是“高层组件”，而披萨实现是“底层组件”，很清楚地，PizzaStore依赖这些具体披萨类

应用原则

此时高层组件PizzaStore和底层组件（就是这些比萨）都依赖了Pizza抽象。

05抽象工厂

需求

建造一家成产原料的工厂，并将原料运送到各家加盟店【有些加盟店，使用低价原料来增加利润，你必须采取一些手段，以免回调你的披萨店平牌】

建造原料厂

public interface PizzaIngredientFactory{
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();
    public Veggies[] createVeggies();
    public Pepperoni createPepperoni();
    public Clams createClams();
}

要做的事情是：
1.为每个区域建造一个工厂，需要创建一个继承自PizzaIngredientFactory的子类来实现每一个创建方法。
2.实现一组原料类供工厂使用，例如ReggianoCheese，RedPeppers,ThickCrustDough.这些类可以在何时的区域间共享。
3.然后你仍然需要将这一切组织起来，将新的原料工厂整合进旧的PizzaStore

创建原料工厂子类---纽约

public class NYPizzaIngredientFactory implements PizzaIngredientFactory{

    @Override
    public Dough createDough() {
        return new ThinCrusDough();
    }

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce();
    }

    @Override
    public Cheese createCheese() {
        return ReggianoCheese();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies veggies[] = {new Garlic(),new Onion(),new Mushroom(),new RedPepper()};
        return new Veggies;
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Clams createClam() {
        return FreshClams();
    }
}

重做Pizza类

public abstract class Pizza{
    //每个pizza持有一组原料
    String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clams;

    public abstract void prepare();//该方法收集来自工厂的原料

    //除了prepare()方法，其他方法保持不变
    public void cut(){
        System.out.println("Cutting the pizza into diagonal slices");
    }
    public void box(){
        System.out.println("Place pizza in official PizzaStore box");
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void toString2(){
        //这里打印披萨的代码
    }
}

重做Pizza类的子类

class CheesePizza extends Pizza{
    PizzaIngredientFactory ingredientFactory;

    public CheesePizza(PizzaIngredientFactory ingredientFactory){
        this.ingredientFactory=ingredientFactory;
    }

    @Override
    public void prepare() {
        System.out.println("Preparing"+name);
        //每次需要原理的时候，请求工厂生产
        dough=ingredientFactory.createDough();
        sauce=ingredientFactory.createSauce();
        cheese=ingredientFactory.createCheese();
    }
}

PizzaStore类的子类

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("veggie")){
           //……
       }
       return pizza;
   }
}

抽象工厂

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

pizzastore类图

工厂方法和抽象工厂比较

工厂方法

用工厂方法将客户代码从需要实例化的具体类解耦，或者如果事先不知道会需要哪些具体类时，用工厂方法只需要子类化并实现工厂方法!

抽象工厂

任何时候需要创建产品家族，以及想确保客户创建相互关联的产品时，使用抽象工厂。

总结

OO原则：
封装变化
组合优于集承
针对接口编程、而不是针对实现
尽力达到交互对象之间的松耦合设计
类应该对扩展开放，对修改关闭
依赖于抽象，不要依赖于具体类
【我们有了一条新的原则，指导我们尽可能地让事情保持抽象。】
OO模式：
抽象工厂，提供一个接口，用于创建相关或依赖对象的家族，而不必指定它们的具体类
工厂方法，定义一个创建对象的接口，但让子类决定哪个类要实例化。工厂方法让一个类延迟实例化到子类。

要点

1.所有工厂都封装对象的创建。
2.简单工厂虽然不是真正体设计模式，但依然可以为一个简单的方法，将客户从具体类解耦
3.工厂方法靠继承:对象创建被委托给子类，子类实现工厂方法来创建对象
4.抽象工厂靠对象组合:对象创建在工厂接口暴露的方法中实现。
5.所有工厂模式都通过减少应用对具体类的依赖，促进了松耦合。
6.工厂方法的意图，是允许个类延迟实例化到其子类。
7.抽象工厂的意图，是创建相关对象家族，不必依赖于其具体类。
8.依赖倒置原则指导我们避免依赖具体类型，尽量依赖抽象。
9.工厂是强有力的技巧，让我们针对抽象编码，而不是针对具体类。