封装创建(Encapsulating creation)
当你发现需要向某个系统添加一些新类型的时候，最明智的做法就是先利用多态（polymorphism）为这些新类型创建一个公共接口。这可以使系统其余部分的代码与新加入的那些特定类型相分离。加入新的类型可能并不需要更改现有的代码。。。或者至少看上去不需要。初看起来，如果你用上面说的这种设计方法修改代码，那么唯一需要改动的就是继承新类型的地方，但事实上并非完全如此。你仍然需要创建新类型的对象，而且在创建的地方你必须指定用哪个构造函数。因此，如果用于创建对象的那部分代码分散在整个程序里（添加新类型的时候你会面临这个问题），你仍然需要找出所有与类型相关的代码。这种情况下，主要的问题是新类型（对象）的创建而不是新类型的使用（这个问题可以用多态来解决），但实际效果是一样的：添加一个新类型总会带来问题。
解决办法是强制使用一个common factory来创建对象，而不允许创建对象的代码分散在整个系统里。如果所有需要创建对象的那些代码都借助于这个工厂（factory）来完成创建，那么添加新类型的时候你需要做的只是修改这个工厂就可以了。
因为所有面向对象的代码都会用到创建对象，而且大多数情况下你会通过添加新的类型来扩展程序，所以我猜想factory模式（系列）可能是最广泛使用的设计模式。
尽管只有简单工厂方法（Simple Factory Method）才是真正意义上的单件（Singleton），但你会发现每一个特定的工厂类（这些类属于更为通用的factory模式）实际上都只有一个实例。
简单工厂方法（Simple Factory method）
我们用下面的例子，重温一下Shape系统。
（实现factory模式）常用的方法是把factory声明为基类的静态方法（static method）。
//: factory:shapefact1:ShapeFactory1.java
// A simple static factory method.
package factory.shapefact1;
import java.util.*;
import junit.framework.*;
abstract class Shape {
public abstract void draw();
public abstract void erase();
public static Shape factory(String type) {
if(type.equals("Circle")) return new Circle();
if(type.equals("Square")) return new Square();
throw new RuntimeException(
"Bad shape creation: " + type);
}
}
class Circle extends Shape {
Circle() {} // Package-access constructor
public void draw() {
System.out.println("Circle.draw");
}
public void erase() {
System.out.println("Circle.erase");
}
}
class Square extends Shape {
Square() {} // Package-access constructor
public void draw() {
System.out.println("Square.draw");
}
public void erase() {
System.out.println("Square.erase");
}
}
public class ShapeFactory1 extends TestCase {
String shlist[] = { "Circle", "Square",
"Square", "Circle", "Circle", "Square" };
List shapes = new ArrayList();
public void test() {
Iterator it = Arrays.asList(shlist).iterator();
while(it.hasNext())
shapes.add(Shape.factory((String)it.next()));
it = shapes.iterator();
while(it.hasNext()) {
Shape s = (Shape)it.next();
s.draw();
s.erase();
}
}
public static void main(String args[]) {
junit.textui.TestRunner.run(ShapeFactory1.class);
}
} ///:~
factory() 方法需要传入一个参数来决定要创建的Shape的具体类型； 在上面的例子里（参数）碰巧是一个字符串（String），它也可以是其它任意类型。当加入新的Shape类型的时候（我们假定被创建对象的初始化代码是来自系统以外的，而不是像上面那个例子使用一个硬编码（hard-coded）的数组），系统唯一需要改动的代码就是factory（）方法。为了促使创建对象的代码只包含在factory()方法里，特定类型的Shape类的构造函数都被声明为package权限，这样一来只有factory（）方法可以调用这些构造函数，而位于包（package）以外的那部分代码则没有足够的权限（调用这些构造函数）。
多态工厂（Polymorphic factories）
上例中，静态的factory（）方法使得所有创建对象的操作都集中在一个地方完成，这也就是唯一需要你修改代码的地方。这当然是一个还算不错的的解决办法，它封装了创建对象的过程。然而，《设计模式》强调使用Factory Method是为了使不同类型的工厂可以由基本类型的工厂派生（subclass）出来（上面例子是一个特例）。但是，那本书没有给出具体例子，只是重复了用于说明抽象工厂（Abstract Factory）的那个例子（你会在本书下一节看到一个Abstract Factory的例子）。下面的例子，我们修改了ShapeFactory1.java使得工厂方法成为一个单独的类的虚函数。请注意，特定类型的Shape类是根据需要动态加载的。
//: factory:shapefact2:ShapeFactory2.java
// Polymorphic factory methods.
package factory.shapefact2;
import java.util.*;
import junit.framework.*;
interface Shape {
void draw();
void erase();
}
abstract class ShapeFactory {
protected abstract Shape create();
private static Map factories = new HashMap();
public static void
addFactory(String id, ShapeFactory f) {
factories.put(id, f);
}
// A Template Method:
public static final
Shape createShape(String id) {
if(!factories.containsKey(id)) {
try {
// Load dynamically
Class.forName("factory.shapefact2." + id);
} catch(ClassNotFoundException e) {
throw new RuntimeException(
"Bad shape creation: " + id);
}
// See if it was put in:
if(!factories.containsKey(id))
throw new RuntimeException(
"Bad shape creation: " + id);
}
return
((ShapeFactory)factories.get(id)).create();
}
}
class Circle implements Shape {
private Circle() {}
public void draw() {
System.out.println("Circle.draw");
}
public void erase() {
System.out.println("Circle.erase");
}
private static class Factory
extends ShapeFactory {
protected Shape create() {
return new Circle();
}
}
static {
ShapeFactory.addFactory(
"Circle", new Factory());
}
}
class Square implements Shape {
private Square() {}
public void draw() {
System.out.println("Square.draw");
}
public void erase() {
System.out.println("Square.erase");
}
private static class Factory
extends ShapeFactory {
protected Shape create() {
return new Square();
}
}
static {
ShapeFactory.addFactory(
"Square", new Factory());
}
}
public class ShapeFactory2 extends TestCase {
String shlist[] = { "Circle", "Square",
"Square", "Circle", "Circle", "Square" };
List shapes = new ArrayList();
public void test() {
// This just makes sure it will complete
// without throwing an exception.
Iterator it = Arrays.asList(shlist).iterator();
while(it.hasNext())
shapes.add(
ShapeFactory.createShape((String)it.next()));
it = shapes.iterator();
while(it.hasNext()) {
Shape s = (Shape)it.next();
s.draw();
s.erase();
}
}
public static void main(String args[]) {
junit.textui.TestRunner.run(ShapeFactory2.class);
}
} ///:~
现在工厂方法(factory method)出现在它自己的类ShapeFactory里，名字改成了create()方法。它是一个受保护的（protected）方法，也就是说它不能被直接调用，但可以被重载。Shape类的子类必须创建与之对应的ShapeFactory的子类，并且通过重载create（）函数来创建它自己的实例。实际上一系列Shape对象的创建是通过调用ShapeFactory. createShape( ) 来完成的。 CreateShape（）是个静态方法， 它根据传入的标示，通过查找ShapeFactory 的 Map 成员变量找到与之相应的工厂对象 （factory obejct）。 然后，找到的factory对象即被用来创建shape对象，但你可以想象一下更为棘手的问题：（与某种Shape类型相对应的）工厂对象被调用者用来以更为复杂的方式创建对象。但是，大多数情况下你似乎并不需要用到复杂的多态工厂方法（polymorphic factory method），在基类里加一个静态方法（像ShapeFactory1.java 那样）就足以解决问题了。
注意到，ShapeFactory的初始化必须通过加载Map数据成员才能完成（Map的元素是factory对象），而这些初始化代码又位于Shape实现类的静态初始化语句里。这样一来，每加入一个新的类型你就必须得继承原来的类型（指Shape？），创建一个factory，然后添加静态初始化语句用以加载Map对象。这些额外的复杂性又一次暗示我们：如果不需要创建单独的factory对象，那最好还是使用静态工厂方法。
抽象工厂（Abstract factories）
抽象工厂（abstract factory）模式看起来很像前面我们看到的那些factory对象，只不过它有多个而不是一个factory方法。每一个factory 方法创建一个不同类型的对象。基本思想是：在创建工厂对象的地方，由你来决定如何使用该工厂对象创建的那些对象。《设计模式》里给出的例子实现了在不同用户图形界面（GUIs）之间的可移植性：你根据自己使用的GUI来创建一个与之对应的factory对象，在这以后，当你需要用到菜单，按钮，滚动条这些东西的时候，它会根据你使用的GUI自动创建合适的对象。这样，你就可以把实现不同GUI之间切换的代码分离出来，使它集中在一个地方。
作为另外一个例子，假设你要创建一个通用的游戏环境，而且你还想要支持不同类型的游戏。下面的例子用抽象工厂给出了它的一种可能的实现。
//: factory:Games.java
// An example of the Abstract Factory pattern.
package factory;
import junit.framework.*;
interface Obstacle {
void action();
}
interface Player {
void interactWith(Obstacle o);
}
class Kitty implements Player {
public void interactWith(Obstacle ob) {
System.out.print("Kitty has encountered a ");
ob.action();
}
}
class KungFuGuy implements Player {
public void interactWith(Obstacle ob) {
System.out.print("KungFuGuy now battles a ");
ob.action();
}
}
class Puzzle implements Obstacle {
public void action() {
System.out.println("Puzzle");
}
}
class NastyWeapon implements Obstacle {
public void action() {
System.out.println("NastyWeapon");
}
}
// The Abstract Factory:
interface GameElementFactory {
Player makePlayer();
Obstacle makeObstacle();
}
// Concrete factories:
class KittiesAndPuzzles
implements GameElementFactory {
public Player makePlayer() {
return new Kitty();
}
public Obstacle makeObstacle() {
return new Puzzle();
}
}
class KillAndDismember
implements GameElementFactory {
public Player makePlayer() {
return new KungFuGuy();
}
public Obstacle makeObstacle() {
return new NastyWeapon();
}
}
class GameEnvironment {
private GameElementFactory gef;
private Player p;
private Obstacle ob;
public GameEnvironment(
GameElementFactory factory) {
gef = factory;
p = factory.makePlayer();
ob = factory.makeObstacle();
}
public void play() { p.interactWith(ob); }
}
public class Games extends TestCase {
GameElementFactory
kp = new KittiesAndPuzzles(),
kd = new KillAndDismember();
GameEnvironment
g1 = new GameEnvironment(kp),
g2 = new GameEnvironment(kd);
// These just ensure no exceptions are thrown:
public void test1() { g1.play(); }
public void test2() { g2.play(); }
public static void main(String args[]) {
junit.textui.TestRunner.run(Games.class);
}
} ///:~
在上面的游戏环境里，Player对象与Obstale对象交互，根据你所选择的游戏类型，player和obstacle的各自类型也会不同。你通过选择某个特定的GameElementFactory来决定游戏的类型，然后GameElementFactory会控制初始化和游戏的进行。在上面的例子里，初始化和游戏的进行都非常简单，但那些活动（初始条件和状态变化）可以在很大程度上决定游戏的结局。这里，GameEnvironment不是用来给其它类继承的 ，尽管那么做很可能也说的通。
上面的代码也包含了双向分发（Double Dispatching）和工厂方法（Factory Method）两种模式，我们会在后面讲解它们。
练习：
1． 写一个Triangle（三角形）类，添加到ShapeFactory1.java。
2． 写一个Triangle（三角形）类，添加到ShapeFactory2.java。
3． 给GameEnvironment添加新的类型，写一个GnomesAndFairies添加到Games.java。
4． 改写ShapeFactory2.java，用一个Abstract Factory来创建不同规格（sets）的shapes(比如说，用一个特定类型的工厂对象来创建“thick shapes”，用另外一个工厂对象来创建“thin shapes”，但是每个工厂对象都可以创建所有类型的shapes，包括：circles，squares，triangles等等。)。
