单例模式（single pattern）

单例模式的优点：

1.一个静态实例,把共享的属性方法能在任何一个程序集调用,信息有效的实现操作。（数据以一个静态实例的模式贯通全局）

2.有效降低大模块之间的耦合度。

（注意：缺点就是耗费内存资源。单例不能滥用）

（注意：单例模式，顾名思义。只有一个实例的设计模式。）

单利模式的由来：

我们只要仔细地想想看，全局变量确实可以提供一个全局访问点，但是它不能防止别人实例化多个对象。通过外部程序来控制的对象的产生的个数，势必会系统的增加管理成本，增大模块之间的耦合度。所以，最好的解决办法就是让类自己负责保存它的唯一实例，并且让这个类保证不会产生第二个实例，同时提供一个让外部对象访问该实例的方法。自己的事情自己办，而不是由别人代办，这非常符合面向对象的封装原则。

通用类写法：（提供三种常用的）

1.类只有一个实例

1 package  2 {
     3     public class Single  4     {
     5         private static var instance:Single = new Single();  6          7         private var _name:String = '';  8          9         public function get name():String 10         {
    11             return _name; 12         } 13         14         public function set name(value:String):void 15         {
    16             _name = value; 17         } 18         19         public function Single() 20         {
    21             if(instance) 22             {
    23                 throw new Error("Single.getInstance()获取实例"); 24             } 25         } 26         27         public static function getInstance():Single 28         {
    29             return instance; 30         } 31     } 32 }

2.类可以有多个实例,内部实例能贯通全局

1 package  2 {
     3     public class Single  4     {
     5         private static var instance:Single;  6          7         private var _name:String = '';  8          9         public function get name():String 10         {
    11             return _name; 12         } 13         14         public function set name(value:String):void 15         {
    16             _name = value; 17         } 18         19         public function Single() 20         {
    21             22         } 23         24         public static function getInstance():Single 25         {
    26             if(instance == null) 27             {
    28                 instance = new Single(); 29             } 30             return instance; 31         } 32     } 33 }

3.只有一个实例,用内部类实现只能实例化一次,外部不能访问该内部类自然就实例化不了

1 package  2 {
     3     public class Single  4     {
     5         private static var instance:Single;  6          7         private var _name:String = '';  8          9         public function get name():String 10         {
    11             return _name; 12         } 13         14         public function set name(value:String):void 15         {
    16             _name = value; 17         } 18         19         public function Single(content:ConSingle) 20         {
    21             22         } 23         24         public static function getInstance():Single 25         {
    26             if(instance == null) 27             {
    28                 instance = new Single(new ConSingle); 29             } 30             return instance; 31         } 32     } 33 } 34 35 class ConSingle 36 {
    37     38 }

在使用单利模式的时候,请注意一点。

不要在单例里面直接写属性（如：public var name:String）当必须写属性的时候用静态属性（public static var name:String）,一般单例模式上面使用的是方法。(getInstance().getName());

如：

1 private var _name:String;  2  3 public function get name():String  4 {
     5 　　return _name;  6 }  7  8 public function set name(value:String):void  9 {
    10 　　　_name = value 11 }

一般学过汇编的同学应该了解：当访问一个对象属性的时候，是先指向该对象模块地址，然后找到地址盒子，然后再找到内存的再进行使用。如果使用方法的情况下按照这个走，所以调用方法是事半功倍。而使用单例模式直接写public var name直接调用的情况下走的也是方法走的模式,那样路就走远了。而public static var name:String就可以减少走的路，直接找到内存地址就可以使用。（一般人不注意这些。养成习惯吧。）