抽象工厂的工作是将“抽象零件”组装为“抽象产品”。在抽象工厂模式中将会出现抽象工厂，它会将抽象零件组装为抽象产品。也就是说，我们并不关心零件的具体实现，而是只关心接口。我们仅适用该接口将零件组装起来成为产品。
示例程序的功能是将带有层次关系的链接的集合制作成HTML文件。
package bigjunoba.bjtu.factory;
public abstract class Item {
protected String caption;
public Item(String caption) {
this.caption = caption;
}
public abstract String makeHTML();
}Item类是Link类和Tray类的父类。这样，Link类和Tray类就具有可替换性了。caption字段表示项目的“标题”。
package bigjunoba.bjtu.factory;
public abstract class Link extends Item {
protected String url;
public Link(String caption, String url) {
super(caption);
this.url = url;
}
}Link类是抽象地表示HTML的超链接的类。url字段中保存的是超链接所指向的地址。由于Link类中没有实现父类的抽象方法makeHTML，因此它也是抽象类。
package bigjunoba.bjtu.factory;
import java.util.ArrayList; public abstract class Tray extends Item {
protected ArrayList<Item> tray = new ArrayList<Item>();
public Tray(String caption) {
super(caption);
}
public void add(Item item) {
tray.add(item);
}
}
Tray类表示的是一个含有多个Link类和Tray类的容器。add方法将Link类和Tray类集合在一起。同理，也没有实现父类的抽象方法makeHTML，因此它也是抽象类。
package bigjunoba.bjtu.factory; import java.io.*;
import java.util.ArrayList; public abstract class Page {
protected String title;
protected String author;
protected ArrayList<Item> content = new ArrayList<Item>(); public Page(String title, String author) {
this.title = title;
this.author = author;
} public void add(Item item) {
content.add(item);
} public void output() {
try {
String filename = title + ".html";
Writer writer = new FileWriter(filename);
writer.write(this.makeHTML());
writer.close();
System.out.println(filename + " 编写完成。");
} catch (IOException e) {
e.printStackTrace();
}
} public abstract String makeHTML();
}
Page是抽象地表示HTML页面的类。如果将Link和Tray比喻成抽象的“零件”，那么Page类就是抽象的“产品”。使用add方法向页面中增加Item，output方法首选根据页面标题确定文件名，接着调用makeHTML方法（为了强调调用的是自己的makeHTML方法，直接显式地加上了this）将自身保存的HTML内容写入到文件中。
package bigjunoba.bjtu.factory;
public abstract class Factory {
public static Factory getFactory(String classname) {
Factory factory = null;
try {
factory = (Factory)Class.forName(classname).newInstance();
} catch (ClassNotFoundException e) {
System.err.println("没有找到 " + classname + "类。");
} catch (Exception e) {
e.printStackTrace();
}
return factory;
}
public abstract Link createLink(String caption, String url);
public abstract Tray createTray(String caption);
public abstract Page createPage(String title, String author);
}Factory类中的getFactory方法，可以根据指定的类名生成具体工厂的实例。getFactory方法通过调用Class类的forName方法来动态地读取类信息，接着使用newInstance方法生成该类的实例，并将其作为返回值返回给调用者。
package bigjunoba.bjtu.test;
import bigjunoba.bjtu.factory.*;
public class Main {
public static void main(String[] args) {
if (args.length != 1) {
System.out.println("Usage: java Main class.name.of.ConcreteFactory");
System.out.println("Example 1: java Main bigjunoba.bjtu.listfactory.ListFactory");
System.out.println("Example 2: java Main bigjunoba.bjtu.tablefactory.TableFactory");
System.exit(0);
}
Factory factory = Factory.getFactory(args[0]);
Link people = factory.createLink("人民日报", "http://www.people.com.cn/");
Link gmw = factory.createLink("光明日报", "http://www.gmw.cn/");
Link us_yahoo = factory.createLink("Yahoo!", "http://www.yahoo.com/");
Link jp_yahoo = factory.createLink("Yahoo!Japan", "http://www.yahoo.co.jp/");
Link excite = factory.createLink("Excite", "http://www.excite.com/");
Link google = factory.createLink("Google", "http://www.google.com/");
Tray traynews = factory.createTray("日报");
traynews.add(people);
traynews.add(gmw);
Tray trayyahoo = factory.createTray("Yahoo!");
trayyahoo.add(us_yahoo);
trayyahoo.add(jp_yahoo);
Tray traysearch = factory.createTray("检索引擎");
traysearch.add(trayyahoo);
traysearch.add(excite);
traysearch.add(google);
Page page = factory.createPage("LinkPage", "杨文轩");
page.add(traynews);
page.add(traysearch);
page.output();
}
}Main类使用抽象工厂生产零件并将零件组装成产品。由于Main类只引入了一个包，所以可以看出，该类并没有使用任何具体零件、产品和工厂。
package bigjunoba.bjtu.listfactory;
import bigjunoba.bjtu.factory.*;
public class ListFactory extends Factory {
public Link createLink(String caption, String url) {
return new ListLink(caption, url);
}
public Tray createTray(String caption) {
return new ListTray(caption);
}
public Page createPage(String title, String author) {
return new ListPage(title, author);
}
}ListFactory类只是简单地new出了ListLink、ListTray和ListPage的实例。
package bigjunoba.bjtu.listfactory;
import bigjunoba.bjtu.factory.*;;
public class ListLink extends Link {
public ListLink(String caption, String url) {
super(caption, url);
}
public String makeHTML() {
return " <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
}
}ListLink类使用<li>和<a>标签来制作HTML片段。
package bigjunoba.bjtu.listfactory; import bigjunoba.bjtu.factory.*;
import java.util.Iterator; public class ListTray extends Tray {
public ListTray(String caption) {
super(caption);
} public String makeHTML() {
StringBuffer buffer = new StringBuffer();
buffer.append("<li>\n");
buffer.append(caption + "\n");
buffer.append("<ul>\n");
Iterator<Item> it = tray.iterator();
while (it.hasNext()) {
Item item = (Item) it.next();
buffer.append(item.makeHTML());
}
buffer.append("</ul>\n");
buffer.append("</li>\n");
return buffer.toString();
}
}
ListTray类中tray字段保存了所有需要以HTML格式输出的Item，而负责将它们以HTML格式输出的就是makeHTML方法。makeHTML方法首先使用<li>标签输出标题，接着使用</ul>和</li>标签输出每个Item。
每个Item输出为HTML格式的方法就是调用每个Item的makeHTML方法了。这里并不关心变量item中保存的实例的类型究竟是ListLink还是ListTray，只是简单地调用了item.makeHTML()而已。变量item是Item类型的，而Item类又声明了makeHTML方法，而且ListLink类和ListTray类都是Item类的子类，因此可以放心调用。这就是面向对象的优点。
package bigjunoba.bjtu.listfactory; import bigjunoba.bjtu.factory.*;
import java.util.Iterator; public class ListPage extends Page {
public ListPage(String title, String author) {
super(title, author);
} public String makeHTML() {
StringBuffer buffer = new StringBuffer();
buffer.append("<html><head><title>" + title + "</title></head>\n");
buffer.append("<body>\n");
buffer.append("<h1>" + title + "</h1>\n");
buffer.append("<ul>\n");
Iterator<Item> it = content.iterator();
while (it.hasNext()) {
Item item = (Item) it.next();
buffer.append(item.makeHTML());
}
buffer.append("</ul>\n");
buffer.append("<hr><address>" + author + "</address>");
buffer.append("</body></html>\n");
return buffer.toString();
}
}
ListPage类和ListTray类差不多。
当只有一个具体工厂的时候，是完全没有必要划分“抽象类”与“具体类”的。还要增加一个tablefactoty将链接以表格形式展示出来。
代码结构如上图，这里就不写tablefactory部分的代码了。
<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<ul>
<li>
日报
<ul>
<li><a href="http://www.people.com.cn/">人民日报</a></li>
<li><a href="http://www.gmw.cn/">光明日报</a></li>
</ul>
</li>
<li>
检索引擎
<ul>
<li>
Yahoo!
<ul>
<li><a href="http://www.yahoo.com/">Yahoo!</a></li>
<li><a href="http://www.yahoo.co.jp/">Yahoo!Japan</a></li>
</ul>
</li>
<li><a href="http://www.excite.com/">Excite</a></li>
<li><a href="http://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
<hr><address>杨文轩</address></body></html>
执行javac Main.java bigjunoba.bjtu.listfactory/ListFactory.java后的结果如上。
<html><head><title>LinkPage</title></head>
<body>
<h1>LinkPage</h1>
<table width="80%" border="3">
<tr><td><table width="100%" border="1"><tr><td bgcolor="#cccccc" align="center" colspan="2"><b>日报</b></td></tr>
<tr>
<td><a href="http://www.people.com.cn/">人民日报</a></td>
<td><a href="http://www.gmw.cn/">光明日报</a></td>
</tr></
执行javac Main.java bigjunoba.bjtu.tablefactory/TableFactory.java后的结果如上。
抽象工厂模式的类图。
抽象工厂的特点：
1.易于增加具体的工厂。假如要增加新的具体工厂，那么需要做的就是编写Factory、Link、Tray和Page这4个类的子类，并实现它们定义的抽象方法。这样，无论增加多少个具体工厂，都无需修改抽象工厂和Main部分。
2.难以增加新的零件。假如要在factory包中增加一个表示图像的Picture零件，那就必须要对所有的具体工厂进行相应的修改才行。例如，需要在listfactory包中就必须做到假如createPicture方法和新增ListPictrue类，这样编写完成的具体工厂越多，修改的工作量就会越大。