工厂模式

前言

---

烘烤OO的精华，除了new操作符之外，还有更多制造对象的方法。
工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样，客户程序中关于超类的代码就和子类对象创建代码解耦了。

---

简单工厂

---

简单工厂其实不是一个设计模式，反而比较像是一种编程习惯。

工厂factory处理创建对象的细节，一旦有了SimplePizzaFactory，orderPizza()就变成了此对象的客户。

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

把创建Pizza的代码包装进一个类，当以后实现改变时，只需要修改这个类即可。

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

}

• PizzaStore——这是工厂的“客户“，PizzaStore现在通过SimplePizzaFactory取得Pizza的实例。
• SimplePizzaFactory——这是创建Pizza的”工厂“，唯一用到具体Pizza类的地方。创建方法通常申明为静态。
• Pizza——这是工厂的”产品“ ，把Pizza定义为抽象类，具有一些有用的实现，这些实现可以被覆盖。
• CheesePizza、VeggiePizza、ClamPizza、PepperoniPizza是”具体产品“，每个产品都必须实现Pizza接口。

接下来登场的是两个重量级的模式，它们都是工厂。
”实现一个接口“泛指”实现某个超类型（类或接口）的某个方法“

---

工厂方法模式

---

最开始的思路：
NYPizzaFactory nyFactory = new NYPizzaFactory();
PizzaStore nyStore = new PizzaStore(nyFactory);
nyStore.orderPizza(“Veggie”);

新的思路：
把加盟店和创建Pizza捆绑在一起的同时又保持一定的弹性。所要做的事情，就是把createPizza()方法放回到PizzaStore中，不过要把工厂方法设置成”抽象方法“，然后为每个区域风味创建一个PizzaStore的子类。

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里，“工厂方法”现在是抽象的
}

允许子类做决定：

• 每个子类都会覆盖createPizza方法，同时使用PizzaStore定义的orderPizza()方法。甚至可以把orderPizza()方法声明为final，以防止被子类覆盖。
• PizzaStore的createPizza()是一个抽象方法，所以任何的具体Pizza子类型“必须实现这个方法”
• NYStylePizzaStore的createPizza()方法会建立纽约风味的Pizza。

public class NYPizzaStore extends PizzaStore{
    Pizza createPizza(String item){
        if(item.equals("cheese")){
            return new NYStyleCheesePizza();
        }
        else return null;
    }

}

说明：

• createPizza()返回一个Pizza对象，由子类全权负责该实例化哪个具体的Pizza。
• NYPizzaStore扩展自PizzaStore，所以拥有orderPizza()方法以及其他的方法。
• 我们必须实现createPizza()方法，因为在PizzaStore里它是抽象的

声明一个工厂方法：

public abstract class PizzaStore{
    public Pizza orderPizza(String type){
        Pizza pizza;
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    protected abstract Pizza createPizza(String type);

}
abstract Product factoryMethod(String type)

1. 工厂方法是抽象的，所以依赖子类来处理对象的创建
2. 工厂方法必须返回一个产品。超类中定义的方法，通常使用到工厂方法的返回值。
3. 工厂方法将客户和实际创建具体产品的代码分割开来。
4. 工厂方法可能需要参数，也可能不需要来指定所要的产品。

新版工厂方法订购Pizza

1. PizzaStore nyPizzaStore = new NYPizzaStore();//纽约披萨店
2. nyPizzaStore.orderPizza("cheese");//下订单
3. Pizza pizza = createPizza("cheese");//orderPizza调用create方法
4. 最后经过prepare、bake、cut、box处理完成。

public abstract class Pizza {//披萨本身
    String name;
    String dough;
    String sauce;
    ArrayList toppings = new ArrayList();
    void prepare(){
    }
    void bake(){
    }
    void cut(){
    }
    void box(){
    }
    public String getName(){
        return name;
    }
}

public class NYStyleCheesePizza extends Pizza{
    public NYStyleCheesePizza(){
        name = "NY Style";
        dough = "Thin Crust";
        sauce = "Marinara";
        toppings.add("Reggiano");
    }
}

整体认识工厂方法模式
所有工厂模式都用来封装对象的创建，工厂方法模式Factory Method Pattern通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

我们可以看到，将一个orderPizza()方法和一个工厂方法联合方法，就可以成为一个框架。除此之外，工厂方法将生产知识封装进各个创建者，这样的做法也可以被视为一个框架。

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

Product——所有的产品必须实现这个共同的接口，这样一来，使用这些产品的类就可以引用这个接口，而不是具体类。
Creator——Creator是一个类，它实现了所有操纵产品的方法，但不实现工厂方法。Creator所有的子类必须实现这个抽象的factoryMethod()方法。

---

抽象工厂模式

---

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

比萨店的设计变得很棒：具有弹性的架构，而且遵循设计原则。
原料家族：纽约使用一组原料，而芝加哥使用另一组原料……

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()};
        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(){
    }
    void cut(){
    }
    void box(){
    }
    public String getName(){
        return name;
    }
}

继续重做比萨……

public class CheesePizza extends Pizza{
    PizzaIngredientFactory pizzaIngredientFactory;
    public CheesePizza(PizzaIngredientFactory pizzaIngredientFactory){
        this.pizzaIngredientFactory = pizzaIngredientFactory;
    }
    void prepare(){
        dough = pizzaIngredientFactory.createDough();
        sauce = pizzaIngredientFactory.createSauce();
        cheese = pizzaIngredientFactory.createCheese();
    }
}

再回到比萨店

public class NYPizzaStore extends PizzaStore{
    protected Pizza createPizza(String item){
        Pizza pizza = null;
        PizzaIngredientFactory pizzaIngredientFactory = new NYPizzaIngredientFactory();
        if(item.equals("cheese")){
            pizza = new CheesePizza(pizzaIngredientFactory);
            pizza.setName("New York Style Cheese Pizza");
        }
        else
        return null;
        return pizza;
    }
}

---