Actionscript3.0 设计模式

关于设计模式，勿必参考《设计模式——可复用面向对象软件的基础》一书中关于提及设计模式的结构UML图！！！

一、单例模式

保证一个类仅有一个实例，提供一个全局的访问点。

《殿堂之路》说构造函数不能用private控制访问符，但是可以考虑使用包外类实现！！！！！

package zjh
{
	public class Singleton
	{
		private static var singleton:Singleton;
		private function Singleton()
		{
		}
		public static function getInstance():Singleton
		{
			if(singleton==null)
			{
				singleton=new Singleton();
			}else{
				return singleton;
			}
		}
	}
}

二、工厂方法

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
  参与者

    1.Product（抽象产品）
      定义工厂方法所创建的对象的接口。（产品）

package zjh
{
	public interface IWork
	{
		function doWork():void;//抽象产品
	}
}

    2.ConcreteProduct（实现产品）
      实现Product接口。

package zjh
{
	public class StudentWork implements IWork//具体产品1
	{
		public function StudentWork()
		{
		}
		
		public function doWork():void
		{
			trace("学生做作业！");
		}
	}
}

package zjh
{
	public class TeacherWork implements IWork//具体产品2
	{
		public function TeacherWork()
		{
		}
		
		public function doWork():void
		{
			trace("老师改作业！");
		}
	}
}

......等n多产品
    3.Creator（抽象工厂，声明工厂方法）
      声明工厂方法，该方法返回一个Product类型的对象
      Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。
      可以调用工厂方法以创建一个Product对象。

package zjh
{
	public interface IFactory//抽象工厂
	{
		function getWork():IWork;//获得产品
	}
}

    4.ConcreteCreator（具体工厂，重定义工厂方法）
      重定义工厂方法以返回一个ConcreteProduct实例。

package zjh
{
	public class StudentFactory implements IFactory//具体工厂1
	{
		public function StudentFactory()
		{
		}
		
		public function getWork():IWork
		{
			return new StudentWork();
		}
	}
}

package zjh
{
	public class TeacherFactory implements IFactory//具体工厂2
	{
		public function TeacherFactory()
		{
		}
		
		public function getWork():IWork
		{
			return new TeacherWork();
		}
	}
}

......等n多具体工厂
Test：

			var f:IFactory=new StudentFactory();
			f.getWork().doWork();
			
			f=new TeacherFactory();
			f.getWork().doWork();

输出：

学生做作业！
老师改作业！

备注：

Actionscript3.0接口与类的不同：摘自《殿堂之路》

定义接口要使用关键字interface

接口只定义方法，不定义属性。定义的方法包括实例方法、静态方法、getter和setter方法。

所以定义的方法不可以加访问控制符。接口中定义的方法都是public类型。

定义的方法没有任何实现，直接以“；”号结尾

按照编程惯例，一般接口名称以大写字母I开头

三、抽象工厂

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

参与者

1. AbstractFactory
      声明一个创建抽象产品对象的操作接口。

package zjh
{
	public interface IAnimalFactory
	{
		function createCat():ICat;
		function createDog():IDog;
	}
}

2.ConcreteFactory
      实现创建具体产品对象的操作。

package zjh
{
	public class BlackAnimalFactory implements IAnimalFactory
	{
		public function BlackAnimalFactory()
		{
		}
		
		public function createCat():ICat
		{
			return new BlackCat();
		}
		
		public function createDog():IDog
		{
			return new BlackDog;
		}
	}
}

package zjh
{
	public class WhiteAnimalFactory implements IAnimalFactory
	{
		public function WhiteAnimalFactory()
		{
		}
		
		public function createCat():ICat
		{
			return new WhiteCat();
		}
		
		public function createDog():IDog
		{
			return new WhiteDog();
		}
	}
}

3.AbstractProduct
      为一类产品对象声明一个接口。

package zjh
{
	public interface ICat
	{
		function eat():void;
	}
}

package zjh
{
	public interface IDog
	{
		function eat():void;
	}
}

4.ConcreteProduct
      定义一个将被相应的具体工厂创建的产品对象。
      实现abstractProduct接口。

package zjh
{
	public class BlackDog implements IDog
	{
		public function BlackDog()
		{
		}
		public function eat():void
		{
			trace("Black Dog is eat");
		}
	}
}

package zjh
{
	public class WhiteDog implements IDog
	{
		public function WhiteDog()
		{
		}
		public function eat():void
		{
			trace("White Dog is eat");
		}
	}
}

 5.Client
      仅使用由AbstractFactory和AbstractProduct类声明的接口

			var a:IAnimalFactory=new BlackAnimalFactory();
			a.createCat().eat();
			a.createDog().eat();
			
			a=new WhiteAnimalFactory();
			a.createCat().eat();
			a.createDog().eat();

输出：

Black Cat is eat
Black Dog is eat
White Cat is eat
White Dog is eat

备注：

工厂方法模式：
一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。    

 
区别：
工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   
工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。