工厂方法（Factory Pattern）

工厂方法模式定义：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。（注：“决定”不是指模式允许子类本身在运行时做决定，而是指在编写创建者类时，不需要知道实际创建的产品是哪一个。选择了使用哪个子类，自然就决定了实际创建的产品是什么）

假设我们要开一间披萨店，提供不同口味的披萨。

首先有一个PizzaStore的类，里面提供一个orderPizza的方法，让客户选择要购买的Pizza。

最开始想到的是这样写：

public class PizzaStore {
    
    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        
        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;
    }
}

当披萨店增加比萨口味的时候，必须修改if else部分的代码，这样做没有对修改关闭。

所以，将代码会变化的部分提取出来，封装创建对象的代码到另一个类，就是SimplePizzaFactory。

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        
        if(type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if(type.equals("greek")){
            pizza = new GreekPizza();
        } else if(type.equals("pepperoni")){
            pizza = new PepperoniPizza();
        }
        
        return pizza;
    }
}

PizzaStore变成了：

public class PizzaStore {
    
    SimplePizzaFactory factory;
    
    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }
    
    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        
        pizza = factory.createPizza(type);
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

问题：是否只是将问题搬到另一个对象？问题依然存在。

这样做有好处，SimplePizzaFactory可以有许多客户，不仅仅是PizzaStore，如果有一个类，PizzaShopMenu要求获得比萨的价格和描述，它只需与SimplePizzaFactory交互。所以，把创建比萨的代码包装进一个类，当以后实现改变时，只需要修改这个类即可。这就是简单工厂方法。

披萨店发展的很好，现在要在全球各地开分店，但不同区域的口味有差异，比如（纽约风味、芝加哥风味、加州风味）。

 一种做法是，利用SimplePizzaFactory，写出三种不同的工厂NYPizzaFactory，ChicagoPizzaFactory、CaliforniaPizzaFactory。坏处是：比如在中国要开一个China风味的Pizza，要增加一个ChinaPizzaFactory的类，如果披萨的口味增加，比如增加一种不添加任何料的pizza，那么需要修改全部SimplePiizaFactory的子类。

另一种做法是，在实际中，不太可能单独划分不同工厂来生产不同披萨，而且，制造披萨一般是在披萨店现场制造的。那么就需要将制作披萨与披萨店绑定。

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

PizzaStore现在是一个抽象类，让NYStylePizzaStore，ChicagoStylePizzaStore，CaliforniaPizzaFactory继承PizzaStore实现各自的createPizza方法。让不同的披萨店（子类）来决定披萨的做法。坏处是：每增加一种披萨口味，要增加一个继承Pizza的子类和修改全部继承PizzaStore的子类的代码。这就是工厂方法。

现在为确保每家披萨店使用高质量原料，打算建造一家生产原料的工厂，并将原料运送到各家加盟店。问题是，不同地方的原料是不一样的，比如（芝加哥的人喜欢番茄酱料，纽约的人喜欢大蒜番茄酱料。

先定义一个原料工厂接口：

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 perpare();        //现在perpare方法声明为抽象，这个方法实现收集特定pizza的原材料

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }
    void cut() {
        System.out.println("Place pizza in official PizzaStore box");
    }
    void setName(String name) {
        this.name = name;
    }
    String getName() {
        return name;
    }
    public String toString() {
        System.out.println(name);
    }
}

一个Pizza类的子类：

public class CheesPizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;    
    public CheesePizza(PizzaIngredientFactory i) {
        ingredientFactory = i;
    }

    void prepare(){    //现在不同的pizza实现不同的prepare方式
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

再回到披萨店:

public class NYPizzaStore extends PizzaStroe {
    public 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")) {
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
        }
        ......
    
        return pizza;
    }
}    

我们引入一个抽象工厂----原料生产工厂，通过抽象工厂接口，创建产品家族，利用这个接口写代码，就从实际工厂解耦，当增加另一个实际工厂，只需要让它实现这个接口。

这就是抽象工厂模式。