除了使用new操作符之外，还有更多制造对象的方法。你讲了解到实例化这个活动不应该总是公开的进行，也会认识到初始化经常造成“耦合”问题。你将了解工厂模式如何从复杂的依赖中帮你脱困。
当看到new，就会想到具体 所以用的的确是实现，而不是接口。

new 有什么不对劲？

在技术上，new没有错，毕竟这是java的基础部分。真正的犯人是我们的老朋友“改变”，以及踏实如何影响new的使用的。

针对接口编程，可以隔离掉以后系统可能发生的一大堆改变，为什么呢？如果代码是针对接口而写，那么通过多态，他可以与任何新类 实现该接口。但是，当代码使用大量的具体类时，等于是自找麻烦，因为一旦加入新的具体类，就必须改变代码。也就是说你的代码并非“对修改关闭”。想用新的具体类型来扩展代码，必须重新打开它。
记住，这个设计应该 对扩展开放对修改关闭

如何将实例化具体类的代码从应用中抽离，或者封装起来，使它们不会干扰应用的其他部分？

识别变化的方面

披萨店

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;
    }

但是压力来自于增加更多的披萨类型
你发现其他餐厅又多了很多流行风味的披萨：ClamPizza（蛤蜊披萨）、VeggiePizza（素食披萨）。很明显你要赶上他们，需要把这些加入你的菜单中，而最近GreekPizza（希腊披萨）卖的不好，所以你决定将它从菜单中去掉：

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();
    } else if (type.equals("clam")) {
        pizza = new ClamPizza();
    } else if (type.equals("veggie")) {
        pizza = new VeggiePizza();
    }
    //这里是我们不想改变的地方。因为比萨的准备，烘烤，包装，多年都持续不变，所以这部分的代码不会改变，只是发生这些动作的比萨会改变。
    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();
    return pizza;
}

很明显，如果实例化“某些”具体类，将使orderPizza()出问题，而且也无法让orderPizza()对修改关闭，但是，现在我们已经知道哪些会改变，哪些不会改变，该是使用封装的时候了。

封装创建对象的代码

我们称这个新对象为“工厂”。
工厂处理创建对象的细节。一旦有了SimplePizzaFactory,orderPizza()就变成此对象的客户。当需要比萨时，就叫比萨工程做一个。那些orderPizza()方法需要知道希腊比萨和蛤蜊比萨的日子不去不复返了。现在orderPizza()方法只关心从工厂得到了一个比萨，而这个比萨实现了Pizza接口，所以它可以调用prepare()、bake()、cut()、box()来分别进行准备、烘烤、切片、装盒。
建立一个简单披萨工厂

//SimplePizzaFactory是新的类，他只做一件事情:帮它的客户创建比萨
public class SimplePizzaFactory {
    //首先，在这个工厂内定义一个createPizza()方法，所有客户用这个方法来实例化对象。
    public Pizza createPizza(String type) {
        Pizza pizza = null;

        if ("cheese".equals(type)) {

        } else if ("pepperoni".equals(type)) {

        } else if ("clam".equals(type)) {

        } else if ("veggie".equals(type)) {

        }
        return pizza;
    }
}

重做PizzaStore类
修改我们的客户代码，我们要做的是仰仗工厂来为我们创建披萨。

public class PizzaStore {
    //为PizzaStore加上一个对SimplePizzaFactory的引用
    SimplePizzaFactory factory;
    //PizzaStore的构造器，需要一个工厂作为参数。
    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }
    public Pizza orderPizza(String type) {
        Pizza pizza;
        //把new操作符替换成工厂对象的创建方法。这里不再使用具体实例化！
        pizza = factory.createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

定义简单工厂
简单工厂其实不是一个设计模式，反而比较像是一种编程习惯，但由于进场被使用。所以任务是工厂模式。
我们来看看新的披萨店类图：

image.png

再次提醒：在设计模式中，所谓的“实现一个接口”并“不一定”表示“写一个类，并利用implement关键词来实现某个java接口”。“实现一个接口”泛指“实现某个超级类型(可以使类或接口)的某个方法

加盟披萨店

你的披萨店经营有成，击败了竞争者，现在大家都希望比萨店能在自己家附加有加盟店。每家加盟店都可能想要提供不同风味的披萨(纽约，芝加哥，加州)。

我们已经有一个做法……

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

NYPizzaFactory nyFactory=new NYPizzaFactory();
PizzaStore nyStore=new PizzaStore(nyFactory);
nyFactory.orderPizza("Veggie");

但是你想要多一些质量控制……
你发现加盟店确实采用你的工厂创建披萨，但是其他部分，却开始采用他们自创的流程：烘烤的做法有些差异，不要切片，使用其他厂商的盒子。
在我们稍早的SimplePizzaFactory代码之前，制作披萨的代码绑在PizzaStore里，但是这么做却没有弹性，那么，该怎么办。

给披萨店使用的框架

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

public abstract class PizzaStore {
    
    public Pizza orderPizza(String type) {
        Pizza pizza;
        //现在createPizza()方法从工厂对象中移回PizzaStore
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    //在PizzaStore里，“工厂方法”现在是抽象的。
    abstract Pizza createPizza(String type);
}

现在已近有一个PizzaStore作为超类，让每个域类型(NYPizzaFactory，ChicagoPizzaFactory，CaliforniaPizzaFactory)都继承这个PizzaStore，每个子类各自决定如何制造披萨，

允许子类做决定

别忘了，PizzaStore已经有一个不错的订单系统，由orderPizza()方法负责处理订单，我们现在要让createPizza()能够应对这些变化来负责创建正确种类的披萨，做法是让PizzaStore的各个子类负责定义自己的createPizza()方法，所以我们会得到一些PizzaStore具体的子类，每个子类都有自己的披萨变体，而任然适合PizzaStore框架，并使用调试好的orderPizza()方法。

image.png

让我们开家比萨店吧

纽约风味店：

//NyPizzaStore扩展自PizzaStore，所以拥有orderPizza()方法(以及其他方法)。
public class NyPizzaStore extends PizzaStore {
    //createPizza()返回一个Pizza对象，由子类全权负责该实例化哪个具体Pizza
    //必须实现createPizza()方法，因为在PizzaStore里他是抽象的。
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        if ("cheese".equals(type)) {

        } else if ("pepperoni".equals(type)) {

        } else if ("clam".equals(type)) {

        } else if ("veggie".equals(type)) {

        }
        return pizza;
    }
}

披萨类：

public 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("Addubg sauce...");
        System.out.println("Addubg 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("Cuting the pizza into diagonal slices");
    }

    public void box() {
        System.out.println("Place pizza in official 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");
    }

    @Override
    public void cut() {
        //这里覆盖了cut()方法 将比萨切成正方形
        System.out.println("Cutting the pizza into square slices");
    }
}

你已经等得够久了，来吃些披萨吧

       PizzaStore pizzaStore = new NyPizzaStore();
       Pizza pizza = pizzaStore.orderPizza("cheese");
       System.out.println("Ethan ordered a"+pizza.getName()+"\n");

认识工厂方法模式的时候终于到了

所有工厂模式都用来封装对象的创建。工厂方法模式通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。看看类图：

创建者.png

产品.png

另一个观点：平行的类层级

image.png

定义工厂方法模式

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

工厂模式类图

工厂模式类图

工厂方法模式能够封装具体类型的实例化，抽象的Creator提供了一个创建对象的方法的接口，在抽象的Creator中，任何其他实现的方法，都可能使用到这个工厂方法所制造出来的产品，但只有子类真正实现这个工厂方法并创建产品。
看看对象依赖
当你直接实例化一个对象时，就是在依赖它的具体类，返回前页看看这个依赖性很高的比萨店例子，它由披萨店类来创建所有的披萨对象，而不是委托给工厂。

设计原则

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

首先，这个原则听起来很像是“针对接口编程，不针对实现编程”，不是吗？的确很相似，然而这里更强调“抽象”。这个原则说明了：不能让高层组件依赖底层组件，而且，不管高层或底层组件，两者都应该依赖抽象。

让我们看前面，PizzaStore是“高层组件”，而披萨实现是“底层组件”很清楚地，PizzaStore依赖这些具体披萨类。

现在这个原则告诉我们，应该重写代码以便于我们依赖抽象类，而不依赖具体类。对于高层及底层模块都应该如此。

依赖倒置原则，究竟倒置在哪里？
在依赖倒置原则中的倒置指的是和一般OO设计的思考方式完全相反。
你会注意到前面的底层主键现在竟然依赖高层的抽象。同样的，高层组件现在也依赖相同的抽象。

倒置你的思考方式

1、好的,所以你需要试下一个比萨店，你第一件想到的事情是什么？
嗯！比萨店进行准备、烘烤、装盒、所以我的店必须能制作许多不同风味的比萨，例如：芝士比萨、素食比萨、蛤蜊比萨。。。
2、没错！先从顶端开始，然后往下倒具体类。但是，正如你所看到的你不想让比萨理会这些具体类，要不然比萨店将全都依赖这些具体类。现在 倒置 你的想法 、、、 别从顶端开始，而是从比萨Pizza 开始，然后想想看能抽象化些什么？
是的 芝士比萨、素食比萨、蛤蜊比萨都是比萨，所以应该共享一个Pizza接口。

对了 你想要抽象化一个Pizza。

3、很接近了，但是要这么做，必须靠一个工厂来经这些具体类取出比萨店。一旦你这么做了，各种不同的具体比萨类型就只能依赖一个抽象，二比萨店也会一来这个抽象。我们已经倒置了一个商店依赖具体类的设计，而且也倒置了你的思考方式。
既然我已经有一个比萨抽象，就可以开始设计比萨店，而不用理会具体的比萨类了。

下面的指导方针，能避免在OO设计中违反依赖倒置原则：

1、变量不可以持有具体类的引用。
如果使用new，就会持有具体类的引用，你可以改用工厂来避开这样的做法。
2、不要让类派生自具体类。
如果派生自具体类，你就会以来具体类。请派生自一个抽象(接口或抽象类)。
3、不要覆盖基类中已实现的方法。
如果覆盖基类已实现的方法，那么你的基类就不是一个真正适合被继承的抽象。基类中已实现的方法，应该有所有的子类共享。

再回到比萨店

有些家门店使用低价原料来增加利润。必须采取一些手段，确保原料的一致

打算建造一家生产原料的工厂，并将原料运送到各家加盟店。对于这个做法，现在还剩下一个问题。家门店坐落在不同的区域，纽约的红酱料和芝加哥的红酱料是不一样的。所以对于纽约和芝加哥，你准备两组不同的原料。

image.png

建造原料工厂

//这个接口负责创建所有的原料
public interface PizzaIngredientFactory {
    public Dough createDough();

    public Sauce createSauce();

    public Cheese createCheese();

    public Veggies[] createVeggies();

    public Pepperoni createPepperoni();

    public Clams createClam();
    //这里有许多类，每个原料都是一个类
    //在接口中，每个原料都有一个对应的方法创建该原料
    //如果每个工厂实例内部都有某一种通用的机制需要实现，就可以吧这个例子改写成抽象类
}

要做的事情是：

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

创建纽约原料工厂

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Dough createDough() {
        return new ThinCurstDough();
    }

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

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

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

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

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

重做比萨。。。

工厂已经一切就绪，准备生产高质量原料了，现在我们只需要重做比萨，好让它们使用工厂生产出来的原料。先从抽象的Pizza类开始：

public abstract class Pizza {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies veggies[];
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clams;
    abstract void prepare();
    void bake() {
        System.out.println("Back 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");
    }
    public String getName() {
        return name;
    }
    void setName(String name) {
        this.name = name;
    }
    public String printString() {
        //这里打印披萨的代码
        return "";
    }
}

继续重做比萨

现在已经有一个抽象比萨，可以开始创建纽约和芝加哥风味的比萨了 。从今以后家门店必须直接从工厂取得原料。

public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    //要制作比萨，需要工厂提供原料。所以每个比萨类都需要从构造器参数中得到一个工厂，并把这个工厂存储在一个实例中
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }
    @Override
    void prepare() {
        System.out.println("Preparing " + getName());
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}
    //Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂，
    // Pizza类根本不关心这些原料，他只知道如何制作比萨。
    // 现在，Pizza和区域原料之间被解耦，无论原料工厂是在洛基山脉还是西北沿岸地区，Pizza类都可以轻易地复用完全没问题。
    // sauce = ingredientFactory.createSauce();

    
    //sauce：把pizza的实例变量设置为此比萨所使用的某种酱料
    //ingredientFactory：这是原料工厂，pizza不在乎使用什么工厂，只要是原料工厂就行了。
    //createSauce()：方法会返回这个区域所使用的酱料。如果这是一个纽约原料工厂，我们将取得大蒜番茄酱料

再回到比萨店

public class NYPizzaStore extends PizzaStore {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;
        //纽约店会用到纽约比萨原料工厂，由该原料工厂负责生产所有纽约风味比萨所需的原料。
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
        if (type.equals("cheese")) {
             //把工厂传递给每一个比萨，以便比萨能从工厂中取得原料。
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese PizzaOld");
        } else if (type.equals("veggies")) {
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggies PizzaOld");
        } else if (type.equals("clam")) {
            pizza = new ClamPizza(ingredientFactory);
            pizza.setName("New York Style Clam PizzaOld");
        }
        return pizza;

    }
}

一连串的代码改变；我们到底做了些什么？

我们引入新类型的工厂，也就是所谓的抽象工厂，来创建比萨原料家族。
通过抽象工厂所提供的接口，可以创建产品的家族，利用这个接口书写代码，我们的代码将从实际工厂解耦，以便在不同上下文中实现各式各样的工厂，制造出各种不同的产品。例如：不同的区域，不同的操作系统，不同的外观及操作。
因为代码从实际的产品中解耦了，所以我们可以替换不同的工厂来取得不同的行为(例如：取得大蒜番茄酱料，而不是取得番茄酱料)。

定义抽象工厂模式

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

抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道(或关心)实际产出的具体产品是什么，这样一来，客户就从具体的产品中被解耦。

image.png

这是一张更复杂的类图，让我们从PizzaStore的观点来看一看它：

image.png

原则 依赖倒置原则: 依赖抽象，不要依赖具体类.

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

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

要点

• 所有的工厂都是用来封装对象的创建
• 简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户长须从具体类解耦
• 工厂方法使用继承:把对象的创建委托给子类，子类实现工厂方法来创建对象
• 抽象工厂使用对象组合:对象的创建被实现在工厂接口所暴露出来的方法中
• 所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合
• 工厂方法允许类将实例化延迟到子类进行。
• 抽象工厂创建相关的对象家族，而不需要依赖他们的具体类