JsDesignMode第二篇

创建型设计模式
    处理对象创建的设计模式,控制对象的创建来避免基本对象创建时
    可能导致设计上的问题或增加设计上的复杂度
1.简单工厂模式
       1.1也称为静态工厂方法
             由一个工厂对象决定创建某一种产品对象类的实例,创建同一类对象
       1.2类太多,提供一个
            

 //封装在一个函数中,只需要记住这个函数,不需要知道基类
 //这个函数被称为工厂函数,这个模式叫简单工厂模式
        var LoginAlert = function(text){
            this.content = text;
        }
        LoginAlert.prototype.show = function(){
            //显示警示框
        }
        var LoginConfirm = function(text){
            this.content = text;
        }
        LoginConfirm.prototype.show = function(){
            //显示确认框
        }
        var LoginPrompt = function(text){
            this.content = text;
        }
        LoginPrompt.prototype.show = function(){
            //显示提示框
        }
        工厂:
        var PopFactory = function(name){
            switch(name){
                case 'alert':
                    return new LoginAlert();
                case 'confirm':
                    return new LoginConfirm();
                case 'prompt':
                    return new LoginPrompt();
            }
        }

       1.3.上面是对不同的类进行实例化,简单工厂模式的理念是创建对象
                     提取相似的东西,不相似的针对性处理
     

   function createPop(type, text){
            var o = new Object();
            o.content = text;
            o.show = function(){
                //显示方法
            }；
            if(type == 'alert'){
                //警示框
            }
            if(type == 'confirm'){
                //确认框
            }
            if(type == 'prompt'){
                //提示框
            }
        }

     1.4区别
                 第一种是通过类实例化来创建
                       继承同一父类,父类原型上的方法是可以共用的
                第二种是创建一个新对象然后包装增强其属性和功能来实现
                      创建了一个新个体,方法也就不能共用了
2.工厂方法模式
        2.1对产品类的抽象使其创建业务主要负责用于创建多类产品的实例
             只需要添加一个类
             看作一个实例化对象的工厂类,将创建对象的基类放在工厂方法类的原型当中
             安全模式:避免错误,比如未使用new
      

  var Factory = function(type, content){
            if(this instanceof Factory){
                var s = new this[type](content);
                return s;
            }else{
                return new Factory(type, content);
            }
        }
        Factory.prototype = {
            Java : function(content){
                //...
            },
            JavaScript : function(content){
                //...
            }
        }; 

 
3.抽象工厂模式
         对类的工厂抽象使其业务用于对产品类族的创建
4.建造者模式
         将一个复杂对象的构建层与其表示层相互分离,同样的构建过程可采用不同的表示
         关心于创建这个对象的整个过程,甚至每一个细节
       

var Human = function(param){
            this.skill = param && param.skill || '保密'；
            this.hobby = param && param.hobby || '保密'；
        }
        Human.prototype = {
            getSkill : function(){
                return this.skill;
            },
            getHobby : function(){
                return this.hobby;
            }
        }
        var Named = function(name){
            var that = this;
            (function(name, that){
                that.wholeName = name;
                if(name.indexOf('') > -1){
                    that.FirstName = name.slice(0, name.indexOf(''));
                    that.SecondName = name.slice(name.indexOf(''));
                }
            })(name, that);
        }
        var Work = function(work){
            var that = this;
            (function(work, that){
                switch(work){
                    case 'code':
                        that.work = '工程师'；
                        that.workDescript = '每天编程'；
                        break;
                    case 'UI':
                    case 'UE':
                        that.work = '设计师'；
                        that.workDescript = '设计更似一种艺术'；
                        break;
                    default:
                        that.work = work；
                        that.workDescript = 'NOT FOUND'；
                }
            })(work, that);
        }
        Work.prototype.changeWork = function(work){
            this.work = work;
        }
        Work.prototype.changeDescript = function(setence){
            this.workDescript = sentence;
        }
        //建造者类
        var Person = function(name, work){
            var _person = new Human();
            _person.name = new Named(name);
            _person.work = new Work(work);
            return _person;
        }

5.原型模式
        用原型实例指向创建对象的类,使用于创建新的对象的类共享原型对象的属性和方法
        将可复用、可共享、耗时大的从基类中提出来然后放在原型之中
        然后子类将方法和属性继承下来,对于那些需要重写的方法进行重写
        既有了自己的属性和方法又有了原型的属性和方法
6.单例模式
        只允许实例化一次的对象类,只存在一个对象
        为一个对象规划一个命名空间,来井井有条的管理对象上的属性和方法
        为了代码易懂,采用语义化,但是能用的词是有限的,很容易重复
        可以使用命名空间来约束每个人定义的变量
        比如常见的jQuery使用它的方法必须使用它的命名空间
   

     var A = {
            Util : {
                util_method1 : function(){},
                util_method2 : function(){}
                //...
            },
            Tool : {
                tool_method1 : function(){},
                tool_method2 : function(){}
                //...
            },
            Ajax : {
                get : function(){},
                post : function(){}
                //...
            }
        }