当创建一组相互之间有关系的类时，在对象创建期间维护他们之间的这些关系是很重要的。要做到这一点，有一个办法是使用工厂方法Factory Method 设计模式。工厂方法模式是一个创建模式，解决了在没有指定具体类型的情况下创建对象的问题。这经常用在抽象类上，专为创建对象定义一个方法。子类就可以覆盖这个方法来定义要创建的特定对象。
工厂方法模式经常与另一个称为模板方法的模式协作，要更好地理解工厂方法并提供更多的上下文含义，我们也将了解模板方法模式。因为工厂方法利用并建立于相同的概念之上，所以我们将首先了解模板方法模式。
抽象类
抽象类在工厂方法和模板方法模式中扮演主要角色。虽然ActionScript 3.0 并不支持抽象类和抽象方法，但是我们依然可以使用抽象类和抽象方法的概念。一个抽象类是这样的一个类，他总是用来被继承，并从不直接实例化。它的用法与接口相似, 但是有一个主要的区别: 一个接口定义只有公有的方法签名，但是一个抽象类的定义既有接口也有执行。一个抽象类使用抽象方法，他没有什么功能，仅仅作为占位符使用。在其他语言中，如C#以及Java, 你可以使用关键字abstract 定义抽象方法，他告诉子类必须覆盖这个方法。因为ActionScript 3.0并没有一个abstract 关键字，所以你可以考虑一个惯用的方法，那就是在抽象方法内部抛出一个异常。这个方式在编译时不会抛出错误，但是在运行时会。底线是ActionScript 3.0没有确定的途径来强制抽象方法。
关于在ActionScript 3.0中使用抽象类，你必须知道两个关键字。第一个是override 关键字。子类必须使用这个关键字来覆盖定义在基类中的抽象方法。他们的方法签名也必须严格匹配。
另一个关键字是final。这个关键字用在抽象类定义的方法上，使得他的子类无法覆盖这个方法。当我们定义模板方法Template Method模式的时候，我们将使用final 关键字。
模板方法Template Method
模板方法是定义在抽象类中的抽象方法，他放置一套普通的算法来填充（至少是部分）抽象方法。算法的定义是在子类覆盖抽象方法的时候完成的。算法的组织结构保存在模板方法中。
考虑下面的例子，我们有一个抽象类，他定义游戏初始化的方式:
package factoryexample {
public class AbstractGame {
// 模板方法
public final function initialize():void {
createField();
createTeam("red");
createTeam("blue");
startGame();
}
public function createField():void {
throw new Error("抽象方法!");
}
public function createTeam(name:String):void {
throw new Error("抽象方法!");
}
public function startGame():void {
throw new Error("抽象方法!");
}
}
}
在上面的例子中，initialize() 方法就是模板方法。他定义了游戏如何被初始化，首先调用createField() 方法，然后调用createTeam()方法创建组，最后调用startGame() 方法开始游戏。他调用的方法在这个类中并没有定义功能。这些是子类的任务，由子类来定义如何创建场地和如何创建组以及游戏如何开始等等。并且所有的子类都只能够按照这种方式来初始化，因为该模板方法是申明为final属性的，不可被覆盖，也就意味着不会被更改。
现在我们将创建一个FootballGame 类，他将扩展我们的AbstractGame 类。这个子类覆盖抽象方法，该抽象方法被抽象基类中的initialize() 模板方法调用。
package factoryexample {
public class FootballGame extends AbstractGame {
public override function createField():void {
trace("创建足球场地");
}
public override function createTeam(name:String):void {
trace("创建足球队： " + name);
}
public override function startGame():void {
trace("开始足球游戏");
}
}
}
可以看出， FootballGame 类覆盖了 createField(), createTeam()以及 startGame() 等方法，使他们特定于足球游戏。但是，初始化的算法被保留了。同样的技术也可以用来创建一个BaseballGame 或者BastketballGame 类。我们可以用下面的代码来运行这个例子:
package factoryexample {
import factoryexample.FootballGame;
import flash.display.Sprite;
public class FactoryExample extends Sprite {
public function FactoryExample() {
// 创建一个 FootballGame实例
var game:FootballGame = new FootballGame();
// 调用定义在 AbstractGame中的模板方法
game.initialize();
}
}
}
下面显示的是输出面板中的内容。
创建足球场地
创建足球队：红队
创建足球队：蓝队
开始足球游戏
你可以看到，子类中覆盖的方法通过模板方法被调用了。算法保留在模板方法中，而具体的执行细节却遵循子类方法。
工厂方法Factory Method
不用很费神，现在我们可以从前面的模板方法例子转到工厂方法例子了。执行模板方法中的工厂方法是很普通的。
在前面的模板方法例子中，我们的createField() 方法并未返回任何东西，他只是跟踪输出短语 "创建足球场地"。让我们来更新他，使他可以创建并返回一个场地对象。因为不同的游戏有不同的场地类型，所以我们将创建一个接口，名叫IField。所有的场地类都将执行他。我们的接口将只定义一个名叫drawField()的方法:
package factory {
public interface IField {
function drawField():void;
}
}
}
现在我们将建立一个FootballField 类来执行IField 接口。为了不跑题，我们将不会实际绘制一个足球场在舞台上，但是可以由你自己来完成。这里是FootballField 类的基本定义:
package factoryexample {
import factoryexample.IField;
public class FootballField implements IField {
public function drawField():void {
trace("正在绘制足球场地");
}
}
}
工厂模式Factory Method的目的是连接两个或更多独立的但又有关系的类层次结构。第一个类层次结构是AbstractGame 类和他的子类: FootballGame, BaseballGame以及 BastketballGame。我们的第二个类层次结构是现在的IField接口和执行他的类: FootballField, BaseballField以及 BasketballField。AbstractGame 和IField 对象是有关系的，但是这些特定对象的创建却是由该游戏的子类决定的。图5.1展示这些类层次结构。
图 5.1. Factory Method 例子中的类层次结构
现在我们可以重新编写AbstractGame类中的createField() 方法和initialize() 方法以反映IField 对象的存在。我们的createField() 方法现在就是一个工厂方法Factory Method，他返回一个执行IField 接口的对象。initialize() 方法现在可以更进一步调用IField 对象的drawField() 方法:
package factoryexample {
import factoryexample.IField;
public class AbstractGame {
//模板方法Template Method，final关键字的使用，使得所有子类的initialize()方法都完全一样（无法进行覆盖），就像“一个模子刻下来的”一样。
public final function initialize():void {
var field:IField = createField();
field.drawField();
createTeam("red");
createTeam("blue");
startGame();
}
//工厂方法Factory Method
public function createField():IField{
throw new Error("抽象方法!");
}
public function createTeam(name:String):void {
throw new Error("抽象方法!");
}
public function startGame():void {
throw new Error("抽象方法!");
}
}
}
这个抽象类和模板算法还是完全没有特定功能，特定对象的创建还是要靠子类来完成。让我们重新编写FootballGame 类，现在可以让他创建并返回一个FootballField 对象:
package factory {
import factory.FootballField;
import factory.IField;
public class FootballGame extends AbstractGame {
public override function createField():IField {
return new FootballField();
}
public override function createTeam(name:String):void {
trace("创建足球队： " + name);
}
public override function startGame():void {
trace("开始足球游戏");
}
}
}
如果我们运行这个例子，我们将获得这些输出内容:
正在绘制足球场地
创建足球队：红对
创建足球队：蓝色
开始足球游戏
简单工厂方法Simple Factory
工厂方法Factory Method经常被误会。 我们经常听到有人说他的代码是按照工厂方法Factory Method模式编写的，仔细审查了这些代码后发现，他们实际上并不是真正的工厂方法Factory Method。过去我们也经常犯这样的错误: 编写一个像下面这样的类，并认为他就是一个工厂方法Factory Method:
package factoryexample {
public class GameFactory {
public static function createGame(gameType:String):IGame {
switch(gameType){
case "football":
return new FootballGame();
case "baseball":
return new BaseballGame();
case "basketball":
default:
return new BasketballGame();
}
}
}
}
如果你认为这就是一个工厂方法，那么请你打消这个念头。因为Factory Method 比这个要复杂得多。实际上上面这个例子根本不是一个设计模式。他通常被称为简单工厂Simple Factory 或参数化工厂方法Parameterized Factory。并不是说她就没有用，实际上我们将在第12章使用这项技术, "状态模式", 基于名称设置状态。
总结
抽象类是面向对象设计中的一个非常重要的工具。他们普遍用在类库和框架方面，因为他们是跨子类提取公共行为的可靠途径。
在你使用抽象类的时候，模板方法和工厂方法设计模式就是最适合的，也很方便。模板方法允许你创建一个带有普遍性的公共算法，他的特定步骤将由具体的子类来定义。工厂方法允许你触发抽象类中对象的创建，但是将特定类型的对象的创建指向子类。