特化创建(Specialized creation)
原型模式(Prototype)
通过克隆某个原型的实例来创建对象。“模式重构(Pattern Refactoring)”一章会给出这种模式的一个例子。
生成器模式(Builder)
Builder模式的目的是为了将对象的构造与它的“表示”（representation）分离开来，这样对象就可以有多个不同的“表示”。对象构造的过程保持不变，但是最终创建的对象可以有不同的表示。GoF指出，Abstract Factory模式与Builder模式的主要区别就在于Builder模式遵循一定的步骤一步步创建对象，这样一来，按照时间顺序创建对象就显得非常重要了。此外，“director”似乎是In addition, it seems that the “director” gets a stream of pieces that it passes to the Builder, and each piece is used to perform one of the steps in the build process.
GoF给出的一个例子是文本格式转换器。待转换的文本是RTF格式的，当解析文本的时候，解析指令被传给文本转换器，文本转换器根据不同的输出格式（ASCII，TeX，或者“GUI文本工具”）可能有不同的实现。尽管最终生成的“对象”（整个转换后的文件）是over time的？？？，但是如果把每个RTF格式的转换指令都认为是一个对象，我觉得这更像是Bridge模式，因为某一具体类型的转换器扩展了基类的接口。另外，这个问题通常的解决方案使得前端（front end）可以有多个读取者，而转换器则在后端(back end)工作, 这正是Bridge模式的主要特征。
在我看来，Builder和常规factory最本质的区别在于，Builder用多个步骤来创建对象，而且这些步骤对于Builder对象来说都是外部的。但是，GoF 强调的是（通过Builder）你可以用同样的步骤创建不同的对象实体（representations）。他们从未说明“representation”到底指什么。（难道说“representation”是指过大的对象？ 那么，如果对象实体被分割成小的对象，是否就不需要使用Builder了呢？）
GoF 还给出了另外一个例子，创建迷宫对象，在迷宫内部添加房间，给房间加上门。这是一个需要多部完成的过程，但是，所谓不同的 “对象实体（representations）”，也就是是“常规的（standard）”和“复杂的(complex)”迷宫――实际上并不是说它们是不同类型的迷宫，而是指它们的复杂程度不一样。换了是我的话，我想我会试图创建一个迷宫构造器（maze builder）用它来创建任意复杂度的迷宫。Maze builder的最终变体其实根本就不创建迷宫对象了，它只是计算现有迷宫所包含的房间数量。
RFT转换器和迷宫构造器这两个例子都不是讲解Builder模式的非常有说服力的例子。有读者建议说Sax的XML解析器，或者是标准的编译器解析器可能更适合用来说明Builder模式。
下面这个例子可能比较适合用来说明Builder模式，至少它更能说明Builder模式的意图。我们可能会把媒体（media）创建为不同的表现形式，本例中可能是书籍，杂志或者网站。这个例子主要说明创建对象的步骤是相同的，这样它们才可以被抽象到director类里。
//: builder:BuildMedia.java
// Example of the Builder pattern
package builder;
import java.util.*;
import junit.framework.*;
// Different "representations" of media:
class Media extends ArrayList {}
class Book extends Media {}
class Magazine extends Media {}
class WebSite extends Media {}
// ... contain different kinds of media items:
class MediaItem {
private String s;
public MediaItem(String s) { this.s = s; }
public String toString() { return s; }
}
class Chapter extends MediaItem {
public Chapter(String s) { super(s); }
}
class Article extends MediaItem {
public Article(String s) { super(s); }
}
class WebItem extends MediaItem {
public WebItem(String s) { super(s); }
}
// ... but use the same basic construction steps:
class MediaBuilder {
public void buildBase() {}
public void addMediaItem(MediaItem item) {}
public Media getFinishedMedia() { return null; }
}
class BookBuilder extends MediaBuilder {
private Book b;
public void buildBase() {
System.out.println("Building book framework");
b = new Book();
}
public void addMediaItem(MediaItem chapter) {
System.out.println("Adding chapter " + chapter);
b.add(chapter);
}
public Media getFinishedMedia() { return b; }
}
class MagazineBuilder extends MediaBuilder {
private Magazine m;
public void buildBase() {
System.out.println("Building magazine framework");
m = new Magazine();
}
public void addMediaItem(MediaItem article) {
System.out.println("Adding article " + article);
m.add(article);
}
public Media getFinishedMedia() { return m; }
}
class WebSiteBuilder extends MediaBuilder {
private WebSite w;
public void buildBase() {
System.out.println("Building web site framework");
w = new WebSite();
}
public void addMediaItem(MediaItem webItem) {
System.out.println("Adding web item " + webItem);
w.add(webItem);
}
public Media getFinishedMedia() { return w; }
}
class MediaDirector { // a.k.a. "Context"
private MediaBuilder mb;
public MediaDirector(MediaBuilder mb) {
this.mb = mb; // Strategy-ish
}
public Media produceMedia(List input) {
mb.buildBase();
for(Iterator it = input.iterator(); it.hasNext();)
mb.addMediaItem((MediaItem)it.next());
return mb.getFinishedMedia();
}
};
public class BuildMedia extends TestCase {
private List input = Arrays.asList(new MediaItem[] {
new MediaItem("item1"), new MediaItem("item2"),
new MediaItem("item3"), new MediaItem("item4"),
});
public void testBook() {
MediaDirector buildBook =
new MediaDirector(new BookBuilder());
Media book = buildBook.produceMedia(input);
String result = "book: " + book;
System.out.println(result);
assertEquals(result,
"book: [item1, item2, item3, item4]");
}
public void testMagazine() {
MediaDirector buildMagazine =
new MediaDirector(new MagazineBuilder());
Media magazine = buildMagazine.produceMedia(input);
String result = "magazine: " + magazine;
System.out.println(result);
assertEquals(result,
"magazine: [item1, item2, item3, item4]");
}
public void testWebSite() {
MediaDirector buildWebSite =
new MediaDirector(new WebSiteBuilder());
Media webSite = buildWebSite.produceMedia(input);
String result = "web site: " + webSite;
System.out.println(result);
assertEquals(result,
"web site: [item1, item2, item3, item4]");
}
public static void main(String[] args) {
junit.textui.TestRunner.run(BuildMedia.class);
}
} ///:~
注意到，从某种角度来说上面这个例子也可以看成是比较复杂的State模式，因为director的行为取决于你所使用的builder的具体类型。Director不是简单的将请求传递给下层的State对象，而是把State对象当作一个Policy对象来使用，最终自己来完成一系列的操作。这么以来，Builder模式就可以被描述成使用某种策略来创建对象。
练习：
1．将一个文本文件作为一系列单词读入（an input stream of words），考虑使用正则表达式。写一个Builder将这些单词读入到一个java.util.TreeSet，然后再写一个Builder创建一个java.util.HashMap用来保存单词和它出现的次数（也就是统计单词出现的次数）。
本文地址：http://com.8s8s.com/it/it28614.htm