先前整理過js作用域和this關鍵字的用法，以及分析過js面向對象各種方式，這些都是實現(xiàn)js面向對象所必須的。忘記的話看這里：http://blog.csdn.net/u012545279/article/details/12969813
首先來分析一下js中實現(xiàn)面向對象的重要成員prototype，進而在此基礎上講解繼承實現(xiàn)；
=====================================================================
javascript的原型模式：
js中創(chuàng)建的每一個函數(shù)都有一個prototype屬性，這個屬性是一個指針，指向一個對象，這個對象是包含由特定類型的所有實例共享
的屬性和方法。也就是說prototype是通過調(diào)用構造函數(shù)而創(chuàng)建的那個對象實例的原型對象。通過原型對象可以讓所有對象實例共享
其屬性和方法。例如：
function Person(){
? ? ? this.name="張三"
}
Person.prototype.age="26";
?Person.prototype.say=function(){
? ? ? ?alert(this.name);
? ? ? ?alert(this.age);
?}
? var person_new=new Person();
? ?var person_new1=new Person();
? ?person_new.say();//張三，26;
用代碼解釋就是 Person是一個構造函數(shù)，person_new是調(diào)用構造函數(shù)創(chuàng)建的對象實例，name是構造函數(shù)的成員屬性，age是通過
prototype原型對象中的一個原型屬性。say是原型對象的一個可以由所有實例共享的方法。
通過prototype創(chuàng)建的屬性和方法是由所有實例共享的，也就是說person_new.say==person_new1.say;
要理解原型模式首先要理解原型對象性質(zhì)
---------------------------------------------------------------------------------------------
原型對象：
所有函數(shù)在創(chuàng)建時候都會根據(jù)一組特定規(guī)則為自己創(chuàng)建一個prototype屬性，而該屬性指向了函數(shù)的原型對象。這個原型對象默認情況下會取得constructor屬性，這個屬性包含一個指向prototype所在函數(shù)的指針，也就是Person.prototype.constructor=Person。調(diào)用構造函數(shù)創(chuàng)建一個新實例時候，該實例會包含一個指針指向構造函數(shù)的原型對象，一般來說是__proto__,它存在于實例與構造函數(shù)的原型對象中。利用isPrototypeOf()方法可以確定實例與原型對象的關系：Person.prototype.isPrototypeOf(person_new)//true。
如果我們在實例中添加一個屬性，而該屬性與原型中一個屬性同名，那么我們就相當于在實例中創(chuàng)建了一個該屬性，該屬性會屏蔽原型中那個屬性（不是覆蓋）。例如：
person_new.age="27";
alert(person_new.age)//"27";
person_new.hasOwnProperty('age')//true
"age"in person_new//true
delete person_new.age;
alert(person_new.age)//"26";
person_new.hasOwnProperty('age')//false
"age" in person_new//true;
要檢驗一個屬性或者方法是存在原型中還是存在實例中用hasOwnProperty方法：存在實例中則返回true，否則返回false；
用in操作符與hasOwnProperty一起檢測可以判斷是否存在該屬性以及該屬性存在實例中還是原型中；
更加優(yōu)雅的""原型對象"：
Person.prototype={
? ? ? age:"26",
? ? ? name:"lisi"
}
這種寫法在實際應用中常見，其返回結果跟之前寫法是一樣的，但是需要注意的是這種寫法其實是完全重寫了默認的prototype對象(實際就是以對象字面量形式為prototype對象創(chuàng)建了一個新對象object)，先前也說過每次創(chuàng)建一個函數(shù)都會創(chuàng)建一個prototype對象，該對象同時就獲得constructor屬性。而在我們重寫了默認prototype對象后constructor就不再指向Person了，而是指向了object。如果想再次將constructor指向原函數(shù)，只需在object里增加：constructor：Person.
原型對象問題：
原型對象的作用是所有屬性都是被很多實例共享的。也正是由于這個作用，使得一些引用類型例如array就不適合在原型對象中定義了：一個實例改變了該引用類型的值另一個實例訪問時候也是改變后的值。
---------------------------------------------------------------------------------------------
構造方法+原型對象
利用構造函數(shù)存儲定義實例屬性，原型對象定義方法和共享的屬性。這樣每個實例都會有自己的一份實例屬性副本，又同時共享原型對象的方法的引用。還支持向構造函數(shù)傳遞參數(shù)，最大節(jié)約了內(nèi)存：
function Person(name age){
? ? ? this.name=name;
? ? ? this.age=age;
? ? ? this.love=["basketBall","football"]
}
Person.prototype={
? ? ? constructor:Person,
? ? ? sayName:function(){
? ? ? ? ? ? alert(this.name)
? ? ? }
}
=======================================================================
繼承實現(xiàn)：
ecmascript中實現(xiàn)繼承的方式主要依靠原型鏈來實現(xiàn)，那么什么是原型鏈呢？上面講到的原型對象跟原型鏈有什么關系么。
---------------------------------------------------------------------------------------------
原型鏈：
原型鏈基本思想如下：
上面說過每個構造函數(shù)都有一個原型對象prototype，原型對象都包含一個指向構造函數(shù)的指針constructor，每個實例都包含一個指向原型對象的指針__proto__;
如果我們讓原型對象等于另一個類型的實例，那么結果將是此時的原型對象包含一個指向另一個原型的指針，而另一個原型中也包含著指向另一個構造函數(shù)的指針，加入另一個原型又是第三個類型的實例，那么上述關系依然成立。以此層層推進，就實現(xiàn)了實例與原型的鏈條，這就是所謂的原型鏈；其實現(xiàn)方式如下代碼：
function Person(){
? ? ? this.name="zhangsan";
? ? ? this.love=["basketball","football"]
}
Person.prototype.getName=function(){
? ? ? return this.name;
}
function man(){
? ? ? ?this.age="26";
}
man.prototype=new Person();
man.prototype.getAge=function(){
? ? ? return this.age;
}
var yuchao=new man();
上面代碼中man和Person是兩個類型，man通過創(chuàng)建Person的實例并將該實例賦給man.prototype實現(xiàn)繼承了Person，此時yuchao指向
了man的原型，man的原型又指向Person的原型，yuchao.constructor現(xiàn)在指向的不是man而是Person（因為man的原型指向了Person
的原型）。需要注意的是 這時候的man原型是Person的實例賦給的，如果把getAge方法放到 man.prototype={getAge:function()
{}}這樣寫 就完全破壞了設想中的原型鏈，因為此對象字面量寫法相當于重寫了man的原型 使其指向一個object實例而不是Person的實例。
----------------------------------------------------------------------------------------
原型鏈問題及組合繼承：
原型鏈問題 實際就是上面說的原型對象問題，上面說過，包含引用類型的原型屬性會被所有實例共享，這也就是為什么上面要用構造方法+原型對象結合生成“js類”。拿上面代碼做例子：
yuchao.love.push("music");
yuchao.love//basketball,football,music;
var xiaopu=new man();//新建另外的實例
xiaopu.love//basketball,football,music;
在第一個實例中我們將love數(shù)組push一個music，在另外的新建所有實例中都共享了這個新數(shù)組，這明顯不是我們想要的結果；
在解決原型鏈問題時候我們可以組合使用借用構造函數(shù)+原型鏈這樣一種組合繼承方式，從而達到使用原型鏈實現(xiàn)對原型屬性和方法
的繼承，又能通過借用構造函數(shù)實現(xiàn)對實例屬性繼承。（以下為完整代碼）：
function Person(name){
? ? ? this.name=name;
? ? ? this.love=["basketball","football"]
}
Person.prototype.sayName=function(){
? ? ? ?alert(this.name)
}
function man(name,age){
? ? ? ?Person.call(this,name);//調(diào)用父類構造方法，使得子類的實例對象都是初始化代碼
? ? ? ?this.age=age;
}
man.prototype=new Person();
//再實例化Person為man的原型對象時候love就是構造函數(shù)的屬性而不是直接添加到man原型對象中
man.prototype.sayAge=function(){
? ? ? ?alert(this.age);
}
var yuchao=new man("zhangsan","26");
這樣既能達到每個實例能實現(xiàn)原型的函數(shù)復用，又能保證每個實例都有自己屬性，從而實現(xiàn)最好的繼承方式
