【设计模式】之抽象工厂（Abstract Factory）

抽象工厂的定义为：不需要指定具体的类，为创建一系列有关联或有依赖关系的对象提供一个接口（Provide an interface for creating families of related or dependent objects without specifying their concrete  classes）。

由定义可以看出，抽象工厂生产的是一系列产品（families of products），这就是与工厂方法（Factory Method）的区别所在；还有一点就是生产出的产品具有相关性（related or dependent），因为同一类别的产品是在一个工厂中生产的，因而抽象工厂可以满足这个约束（constraint），同时这点也是在使用抽象工厂模式时需要注意的事项 ---- 保持对象的一致性。

抽象工厂可以不抽象，这样它可以同时被当作抽象工厂和具体工厂，子类工厂在继承的时候可以选择自己需要的产品去生产，不必生产每一种产品。

抽象共产生产的每一种产品可以使用工厂模式，如果产品的种类太多，为避免过多的继承，则可以使用原型模式（Prototype）。

实例代码如下（java）

1 首先定义一个工厂的接口，接口中定义了生产每一种产品的方法，用到了工厂方法（Factory Method）。

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

2 定义一个具体的工厂

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[] createVigges() {
        Veggies[] veggies = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }

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

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

3 定义产品的基类

public abstract class Pizza {
    String name;
    String dough;
    String sauce;
    Veggies[] veggies;
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

    abstract void prepare();

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

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

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    public String toString() {
        // code to print pizza here
    }
}

3 具体的产品类

public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

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

    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

public class ClamPizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

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

    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
        clam = ingredientFactory.createClam();
    }
}

3 使用工厂类

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")) {
            pizza = new VeggiePizza(ingredientFactory);
            pizza.setName("New York Style Veggie Pizza");
        } else if (item.equals("clam")) {
            pizza = new clamPizza(ingredientFactory);
            pizza.setName("New York Style Clam Pizza");
        } else if (item.equals("pepperoni")) {
            pizza = new PepperoniPizza(ingredientFactory);
            pizza.setName("New York Style Pepperoni Pizza");
        }
        return pizza;
    }
}

由于常常只用到一个工厂类的实例，因此可以把子类工厂类定义为singleton，这样也可以使用到lazy initialization。