设计模式之工厂模式

• 有很多店卖很多不同种类的pizza，但对制作好的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;
    }

    protected abstract Pizza createPizza(String type);

}

• 两种具体的工厂

public class NYPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String type) {
        if (type.equals("NY")) {
            return new NYStyleCheesePizza();
        } else {
            return null;
        }
    }

}

public class ChicagoPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String type) {
        if (type.equals("Chi")) {
            return new ChicagoStyleCheesePizza();
        } else {
            return null;
        }
    }

}

• 产品类

import java.util.ArrayList;

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

    void prepare() {
        System.out.println("Preparging" + 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));
        }
    }

    void bake(){
        System.out.println("Bake for 25 min at 350");
    }

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

    void box(){
        System.out.println("Place pizza in official PizaStore box");
    }

    public String getName(){
        return name;
    }

}

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

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

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

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

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

}

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

• 依赖倒置原则：要依赖抽象，不要依赖具体类。
  
  1. 变量不可以持有具体类的引用
  2. 不要让类派生自具体类
  3. 不要覆盖类中已实现的方法

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

• pizza原料接口

public interface PizzaIngredientFactory {
//  每个原料都是一个类
    public Dough createDough();
    public Sauce createSauce();
    public Cheese createCheese();

}

• 纽约原料工厂

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Cheese createCheese() {
        // TODO Auto-generated method stub
        return NyCheese;
    }

    @Override
    public Dough createDough() {
        // TODO Auto-generated method stub
        return NYDough;
    }

    @Override
    public Sauce createSauce() {
        // TODO Auto-generated method stub
        return NySauce;
    }

}

• pizza基类

public class NewPizza {
    String name;
    Dough dough;
    Sauce sauce;
    Cheese cheese;

    abstract void prepare();// 在此方法中收集pizza所需要的原料

    void bake() {
        System.out.println("Bake for 25 min at 350");
    }

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

    void box() {
        System.out.println("Place pizza in official PizaStore box");
    }

    public String getName() {
        return name;
    }
}

public class NYCheesePizza extends NewPizza {
    PizzaIngredientFactory ingredientFactory;

    public NYCheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;

    }

    @Override
    void prepare() {
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();

    }

}

比较

• 工厂方法通过继承创建对象，扩展一个类，并覆盖它的工厂方法，客户只需要知道他们所使用的抽象类型，由子类来负责决定具体类型
• 抽象工厂方法通过组合覆盖对象。对象的创建被实现在工厂接口所暴露出的方法中。