AS3中的单件(Singleton)模式

单件(singleton)模式在c#中是最容易实现的模式，其主要用意就在于限制使用者用new来创建多个实例。但在as3中，构造函数必须是public的（语法本身要求的），而且也不能在构造函数中抛出异常(编译可通过，但是逻辑行不通)，因为这样相当于把创建实例的路子完全切断了，一个实例也得不到！

错误代码：

package{
	public class singleton{
		
		static private var _instance:singleton;
		
		public function singleton():void{
			throw Error("单件模式不能用new创建实例!");
		}
		
		public static function getInstance():singleton{
			if (_instance==null){
				_instance = new singleton();//因为上面的构造函数抛出了异常，所以这里运行时会报错
			}
			return _instance;
		} 
			
	}
}

怎样即能创建实例，又阻止使用者调用构造函数呢？这里要用到as3的一个特性：默认情况下，一个as文件，只能放一个类，而且必须用package声明，但有一种特殊情况：一个as文件中定义二个类，一个用package声明，一个不用！没有package的类，默认访问范围为“仅同在一个文件的类可访问”

package
{

	public class SingletonFactory
	{
		private static var _instance:Singleton2=null;

		public function SingletonFactory():void
		{
			trace Error("error!");
		}

		public static function getInstance():Singleton2
		{
			if (_instance == null)
			{
				_instance=new Singleton2();
			}
			return _instance;
		}
	}
}

class Singleton2
{
	import flash.utils.getTimer;

	private var _createTime:uint;

	public function Singleton2()
	{
		_createTime=getTimer();
	}

	public function toString():String
	{
		return "本实例的创建时间：" + _createTime.toString();
	}

	public function helloWorld(name:String):String
	{
		return "hello " + name + " !";
	}
}

测试：

package
{
	import flash.display.Sprite;
	import flash.utils.getTimer;
	
	public class main extends Sprite
	{
		public function main()
		{			
			var a:* = SingletonFactory.getInstance();
			trace(getTimer());
			
			var s1:* = SingletonFactory.getInstance();
			trace(s1.toString());
			
			//空循环，刻意占用cpu，消耗占时间而已
			for(var i:uint=0;i<999999;i++)
			{
				//trace();
			}
			
			trace(getTimer());
			var s2:* = SingletonFactory.getInstance();
			trace(s2.toString());
			
			trace(s1==s2);
			
			trace(s1.helloWorld("jimmy"));
			
			
		}
	}
}

但这里有一个不爽的地方，SingleTon2类离开了文件SingletonFactory.as就无法访问了，所以我们在使用时，只能用var s1:* 来声明，虽然可以使用，但是在fd,fb等编程环境中却无法获得代码自动感知！

可以借助接口改进一下：

package
{
	public interface ISingleton
	{
		function toString():String;
		
		function helloWorld(name:String):String;
	}
}

然后让SingleTon2实现该接口

package
{

	public class SingletonFactory
	{
		private static var _instance:Singleton2=null;

		public function SingletonFactory():void
		{
			trace Error("error!");
		}

		public static function getInstance():Singleton2
		{
			if (_instance == null)
			{
				_instance=new Singleton2();
			}
			return _instance;
		}
	}
}

class Singleton2 implements ISingleton //这里改为实现接口
{
	import flash.utils.getTimer;

	private var _createTime:uint;

	public function Singleton2()
	{
		_createTime=getTimer();
	}

	public function toString():String
	{
		return "本实例的创建时间：" + _createTime.toString();
	}

	public function helloWorld(name:String):String
	{
		return "hello " + name + " !";
	}
}

重新测试：

package
{
	import flash.display.Sprite;

	public class main extends Sprite
	{
		public function main()
		{
			var s:ISingleton=SingletonFactory.getInstance();
			trace(s.helloWorld("jimmy.yang"));
		}
	}
}

当然明白了上面的原理后，其实可以更一步简化，既然不声明package的类，只能限制在同一个文件内部的其它类可以访问，何不把它做为构造函数的参数?(这样不就限制了从外部调用构造函数么)

package
{
	public class Singleton2
	{
		private static var _instance:Singleton2;
		
		public function Singleton2(n:_nothing)
		{
				
		}
		
		public static function getInstance():Singleton2{
			if (_instance==null){
				_instance = new Singleton2(new _nothing());				
			}	
			return _instance;
		}
	}
}

class  _nothing{}

这样就清爽多了，当然Singleton模式在AS3中的实现方法不止一种，下面这种也许更容易理解:

package{
	
	public class Singleton{
		
		private static var _instance:Singleton = null;
		
		public function Singleton(){
			if(_instance == null){
				_instance = this;
			}else{
				throw Error("已经存在该类的实例!");
			}
		}
		
		public static function getInstance():Singleton{
			if(_instance != null){
				return _instance;
			}
			return new Singleton();
		}		
		
	}
}