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

本文出自 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()，每个方法都被声明为抽象，而子类的方法覆盖这些方法来创建某些对象），抽象工厂的任务是定义一个负责创建一组产品的接口。这个接口内的每个方法都负责创建一个具体产品，同时我们利用实现抽象工厂的子类来提供这些具体的做法，所以，在抽象工厂中利用工厂方法实现生产的做法是相当自然的做法。

比较工厂方法和抽象工厂

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

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

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

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