【设计模式】学习笔记6：抽象工厂模式（Abstract Factory）

本文出自   http://blog.csdn.net/shuangde800

——所有工厂都是用来封装对象的创建

——工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程。

认识抽象工厂模式

在之前的工厂模式已经创建了一个比萨工厂，但是真正要生产的产品——比萨，却还没有涉及到。

比萨店会生产很多不同的比萨产品，而比萨又有格式不同风格的原料。

所以，我们要建造一个工厂来生产原料，这个工厂将负责创建原料家族中的每一个原料：酱料、芝士、面团等。

开始先为工厂定义一个接口，这个接口负责创建所有的原料：

public interface PizzaIngredientFactory {// 接口中，每个原料都有一个对应的方法创建该原料// 下面方法返回各原料对象public Dough createDough();public Sauce createSauce();public Cheese createCheese();public Veggies[] createVeggies();public Pepperoni createPepperoni();public Clams createClam(); }

下面要做的是：

1、给每个比萨店建造一个工厂。需要创建实现PizzaIngredientFactory接口的类，实现接口的方法。

2、实现一组原料类供工厂使用。

3、把这一切组织起来，将新的原料工厂整合进旧的PizzaStore中。

下面创建了纽约原料工厂，实现了PizzaIngredientFactory接口：

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 prepare();//把prepare申明为抽象，在这个方法中，需要手机比萨所需的原料，而这些原料当然是来自原料工厂了void bake() {System.out.println("Bake 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");}void setName(String name) {this.name = name;}String getName() {return name;}public String toString() {StringBuffer result = new StringBuffer();result.append("---- " + name + " ----\n");if (dough != null) {result.append(dough);result.append("\n");}if (sauce != null) {result.append(sauce);result.append("\n");}if (cheese != null) {result.append(cheese);result.append("\n");}if (veggies != null) {for (int i = 0; i < veggies.length; i++) {result.append(veggies[i]);if (i < veggies.length-1) {result.append(", ");}}result.append("\n");}if (clam != null) {result.append(clam);result.append("\n");}if (pepperoni != null) {result.append(pepperoni);result.append("\n");}return result.toString();}}

然后就是创建真正的比萨了！ 比萨店生产的比萨都是继承自Pizza类，假设要生产一个奶酪比萨（CheesePizza）:

// 这是应用了简单工厂模式// 比萨要用到原料，把生产原料任务委托给了ingredientFactory工厂public class CheesePizza extends Pizza {PizzaIngredientFactory ingredientFactory; public CheesePizza(PizzaIngredientFactory ingredientFactory) {this.ingredientFactory = ingredientFactory;}        // 实现prepare方法void prepare() {System.out.println("Preparing " + name);dough = ingredientFactory.createDough();sauce = ingredientFactory.createSauce();cheese = ingredientFactory.createCheese();}}

上面这个真正的比萨，是不是很眼熟？没错，起始就是简单工厂模式， Pizza利用相关的工厂生产原料。所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，它只知道如何制作比萨。现在，Pizza和原料之间被解耦，无论原料工厂是在北京还是上海，Pizza类都可以轻易地复用。

最后，是时候让新的比萨店登场了！ 

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

小结：

上面一连串代码到底做了什么？

其实就做了一件事，引入了新类型的工厂——抽象工厂，来创建比萨原料家族。

我们创建了接口类PizzaIngredientFactory，这个接口可以创建产品的家族，利用这个接口，我们的代码将从实际工厂解耦，以便在不同上下文中实现各式各样的工厂，制作出不同的产品。

定义抽象工厂模式

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

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

生产原料的类图：

我们可以发现抽象工厂主要是为“产品”而服务的。

抽象工厂的方法经常以工厂方法的方式实现（例如createDough(), createSource()，每个方法都被声明为抽象，而子类的方法覆盖这些方法来创建某些对象），抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法，所以，在抽象工厂中利用工厂方法实现生产的做法是相当自然的做法。

比较工厂方法和抽象工厂

      抽象工厂和工厂方法都是负责创建对象，但工厂方法用的是继承，而抽象方法用的是对象的组合

      利用工厂方法创建对象，需要拓展一个类，并覆盖它的工厂方法。整个工厂方法模式，只不过就是通过子类来创建对象。用这种做法，客户只需要知道他们所使用的抽象类型就可以了，而由子类负责决定具体的类型，将客户从具体类型中解耦。

      而抽象工厂用来创建一个产品家族的抽象类型，这个类型的子类定义了产品被产生的方法。要想使用这个工厂，必须先实例化它，然后将它传入一些针对抽象类型所写的代码中。所以和工厂方法一样，也实现解耦。

      总之，他们都能将对象的创建封装起来，使应用程序解耦，并降低对特定实现的依赖。