js面向对象-------->【多种创建对象方法 ：json Object 构造函数模式 原型对象模式 混合模式】★★★★★★★★★★★★★★

开始创建对象：

1.对象字面量。

var clock={
　　hour:12,   //属性
　　minute:10,
　　second:10,
　　showTime:function(){   //方法
　　　　alert(this.hour+":"+this.minute+":"+this.second);
　　}
}
clock.showTime();//调用 

2.创建Object实例

var clock = new Object();   //new一个对象
clock.hour=12;    //对象属性
clock.minute=10;   
clock.showHour=function(){alert(clock.hour);}; //对象方法

clock.showHour();//调用 

由此可见 属性是可以动态添加，修改的

对象创建模式：

1.工厂模式：就是一个函数，然后放入参数，返回对象，流水线工作

【特点】：1.定义一个工厂函数  2.在工厂函数里new一个新对象  3.个此对象创建属性和方法  4.返回此对象   5.[实例化对象]通过new工厂函数，new一个对象 6.最后调用对象。

function createClock(hour,minute,second){ 
　　var clock = new Object();   //new一个对象
　　clock.hour=hour;    //创建属性
　　clock.minute=minute; 
　　clock.second=second; 
　　clock.showHour=function(){   //创建方法
　　　　alert(this.hour+":"+this.minute+":"+this.second); 
   }; 
　　return clock;   //返回此对象
}; 
var newClock = createClock(12,12,12);//实例化 
newClock.showHour();//调用 

【优点】：总算优点抽象的概念了。【缺点】但是不能识别对象的类型呢！

 

2.构造函数模式

【特点】：1.要有this关键字  2.通过this关键字来创建属性和方法

function clock(hour,minute,second){ 
　　this.hour = hour; 
　　this.minute = minute; 
　　this.second = second; 
　　this.showTime = function(){ 
　　　　alert(this.hour+":"+this.minute+":"+this.second); 
　　} 
} 
var newClock =new clock(12,12,12); 
alert(newClock.hour); 

注意:这个new关键字是必须，如果不加，clock就不会当成构造函数调用，而只是一个普通的函数。同时，还会意外地给他的外部作用域即window添加属性，因为此时构造函数内部的this已经映射到了外部作用域了。所以为了安全起见，可以这样创建

 
function clock(hour,minute,second){ 
　　if(this instanceof clock){ 
　　　　this.hour = hour; 
　　　　this.minute = minute; 
　　　　this.second = second; 
　　　　this.showTime = function(){ 
　　　　　　alert(this.hour+":"+this.minute+":"+this.second); 
　　　　} 
　　} 
　　else{ 
　　　　throw new Error("please add 'new' to make a instance"); 
　　　} 
} 

构造函数的【缺点】：【内存空间占有率达】由于this指针在对象实例的时候发生改变指向新的实例。这时新实例的方法也要重新创建，如果n个实例就要n次重建相同的方法。于是让我们来揭开原型模式吧

 

3.原型模式

【特点】：1.关键字prototype  2.先创建一个函数     3.通过prototype原型来创建属性和方法

function clock(hour,minute,second){ } 
　　clock.prototype.hour=12; 
　　clock.prototype.minute=12; 
　　clock.prototype.second=12; 
　　clock.prototype.showTime=function(){ 
　　　　alert(this.hour+":"+this.minute+":"+this.second); 
　　} 
var newClock = new clock(); 
newClock.showTime(); 

深度理解原型模型很重要，

首先，每个函数都有一个prototype(原型)属性，这个指针指向的就是clock.prototype 对象。而这个原型对象在默认的时候有一个属性constructor，指向clock，这个属性可读可写。而当我们在实例化一个对象的时候，实例 newClock除了具有构造函数定义的属性和方法外（注意，只是构造函数中的）,还有一个指向构造函数的原型的指针，ECMAScript管他叫 [[prototype]]，这样实例化对象的时候，原型对象的方法并没有在某个具体的实例中，因为原型没有被实例。（废话有点多，没有误导您吧。别晕）

所以这种模式定义的对象，在调用方法的时候过程：调用newClock.showTime();先看实例中有没有，有调之，无追踪到原型，有调之，无出错，调用失败。

当然可以这样写：【手动指定原型的指向】

 function clock(hour,minute,second){ } 
　　clock.prototype={ 
　　constructor:clock, //必须手动设置这个属性，不然就断了与构造函数的联系了。没有实例共享原型的意义了。 
　　hour:12, 
　　minute:12, 
　　second:12, 
　　showTime:function(){ 
　　　　alert(this.hour+":"+this.minute+":"+this.second) 
　　} 
} 
var newClock = new clock(); 
newClock.showTime(); 

注意：实例与构造函数原型的联系也是通过指针来联系的，故可以动态添加修改原型的方法。

这种纯原型的模式问题也很明显，所有的属性，方法都是共享的，不能让对象具体化。常常我们想每个对象有自己的属性。于是，结合前两种，产生新的模式【构造-原型组合模式】。

4.构造-原型组合模式。【目前比较好的模式】

【特点】：1.构造函数模式和原型对象模式相结合    2.构造函数创建属性   3.原型模式创建方法。  

function clock(hour,minute,second){ 
　　this.hour = hour; 
　　this.minute = minute; 
　　this.second = second; 
} 

clock.prototype.showTime=function(){
alert(this.hour+":"+this.minute+":"+this.second);} 
var newClock = new clock(12,12,12); 
newClock.showTime(); 

【优点】：结合构造函数模式和原型对象模式，集合两者的有点，可以减少内存空间的占用。

这里我们将属性放在构造函数中，更显得对象的具体性。

说明：1.该模式是指混合搭配使用构造函数方式和原型方式
　　   2.将所有属性不是方法的属性定义在函数中（构造函数方式）
           将所有属性值为方法的属性利用prototype在函数之外定义（原型方式）
        3.推荐使用这样方式创建对象,这样做有好处和为什么不单独使用构造函数方式和原型方式，由于篇幅问题这里不予讨论

 5：动态原型方式

 function Parent(){ 
　　this.name="脚本"; 
　　this.age=4; 
　　if(typeof Parent._lev=="undefined"){       //判断此方法是否已经存在，如果已经存在，在实例化对象时，属性的方法不会被重复创建，可以有效减少内存空间的占用。
　　　　　　Parent.prototype.lev=function(){    //动态原型添加方法
　　　　　　return this.name; 
　　　　} 
　　Parent._lev=true; 
　　} 
}; 

var x =new Parent(); 
alert(x.lev()); 

说明：
1.动态原型方式可以理解为混合构造函数，原型方式的一个特例
2.该模式中,属性为方法的属性直接在函数中进行了定义，但是因为

if(typeof Parent._lev=="undefined"){ 
　　Parent._lev=true;
} 

判断方式二：
if (typeof this.getName != 'function') {//通过判断实例封装

　　Person.prototype = {
　　　　constructor: Person,//原型字面量方式会将对象的constructor变为Object，此外强制指回Person

　　　　getName: function () {

　　　　　　return this.name;

　　　　}
　　}

}

 

从而保证创建该对象的实例时，属性的方法不会被重复创建
3.推荐使用这种模式。

 

原文地址：http://www.jb51.net/article/30325.htm