JS中總共有六種繼承模式，包括原型鏈、借用構造函數、組合繼承、原型式繼承寄生式繼承和寄生組合式繼承。為了便於理解記憶，我遐想了一個過程，對6中模式進行了簡單的闡述。 很長的一個故事，姑且起個名字叫女媧造人吧。 創建對象 女媧一個一個的捏人（創建對象），這樣太慢，於是設計了一種機器（函數），想造什麼樣 ...
JS中總共有六種繼承模式，包括原型鏈、借用構造函數、組合繼承、原型式繼承寄生式繼承和寄生組合式繼承。為了便於理解記憶，我遐想了一個過程，對6中模式進行了簡單的闡述。
很長的一個故事，姑且起個名字叫女媧造人吧。
創建對象
女媧一個一個的捏人（創建對象），這樣太慢，於是設計了一種機器（函數），想造什麼樣的，告訴他這個人有哪些特點和功能，機器來製造。這就是工廠模式的（使用同一個介面創建對象，回產生大量重覆代碼，由此發明瞭一種函數（模具））。
但是機器造人同樣也比較麻煩（挖土、和泥、捏眼睛、捏鼻子...）於是封裝的思想來了，鼻子眼睛什麼的提前捏好備用，改造機器，告訴要造的人具有什麼樣的眼睛，鼻子，機器可以直接拿來安裝ok,這樣的機器就是構造函數。
這樣仍然存在問題，假設要讓捏的人都能跑，就要機器給每個人安裝一個‘跑’的功能，這樣工序太慢，還可能出錯，找第三方吧（函數方法定義到構造函數外部，全局作用域中）。第三方負責給我把捏的人都裝上跑的功能，我拿來再放到機器上用，省的每次都加工。ok,人都能跑了，很方便，但是問題又出現了，造的人還需要‘跳’、‘走’..的N個功能，總不能再找N個第三方吧，那這樣建機器就沒意義了。於是女媧（開發人員）早創造了原型模式...厲害了我的媧。
原型模式中每個函數都有一個prototype屬性，是指針，指向原型對象。原型對象包含能讓所有實例共用的屬性和方法，這個原型對象有一個constructor屬性，這個屬性包含一個指向prototype屬性所在函數的指針。
看似有點繞，從女媧這個角度就好理解了：造物主女媧娘娘還發明瞭個各種各樣的模具（原型對象），要開始造了：1造一類人-->用的是造這類人的模具。 畢竟可以造萬物，造什麼用什麼樣的模具。所有造人機器（函數）都有各自唯一的一個模具（原型對象），並且機器有一個標簽[prototype],指向模具，這個模具有能貼生產標誌的[constructor]屬性，指向這個機器，表示是這個機器的模具生產。因此要造什麼樣的一類人，只需要改模具就好了。這就是原型對象的好處，方便，快捷。
生產過程如下： 1造機器A ：function jqA(){}; //有個prototype屬性，指向模具(原型對象)
2造模具：jqA.prototype={
constructor: jqA, //相當於貼上標簽，由A機器生產,
name:'lily',
skin:'white',
run: function(){
alert(this.name+'run'); }
}
這個模具負責造名字叫lili,皮膚為white,能run的這類人。
3 造一個這類型的人 var person1=new jqA();
再造一個這類型的人 var person2=new jaA();
person1和person2都有一個[[prototype]]屬性，表示經過模板A處理了，指向A模板
很完美，問題又來了，這樣生產出來的人都一樣，迎面走來五個一模一樣的白皮膚窈窕美女，然後又有五個一抹一樣的矮挫醜，太可怕了。 所以機器A在用模板的同時，還可以根據女指令來使造的這類人有不同的特點，比如：這個藍眼睛，那個胖點。。這個額外的功能通過構造函數實現---》組合使用構造函數和原型模式
生產過程如下：
//組合使用構造函數模式和原型模式
function Person(name,skill,country) {
this.name=name;
this.age=skill;
this.country=country;
this.member=["劉封","劉嬋"];
} //機器可以聽命令
Person.prototype={
constructor:Person,
sayName:function () {
alert(this.name);
}
} //還可以用模板
var person1=new Person('馬超','鐵騎','蜀國');
var person2=new Person('劉備','仁德','蜀國');
這時候，女媧懶得照顧機器的同時又照顧模板，所以直接把模板裝在了機器中：在構造函數中初始化原型對象---》動態原型模式 更方便了
生產過程如下：
function Person(name,skill,country) {
this.name=name;
this.skill=skill;
this.country=country;
if(typeof this.sayCountry !=undefined){
Person.prototype.sayCountry=function () {
alert(this.country);
};
}
}
var friend=new Person('張飛','咆哮','蜀國');
friend.sayCountry();
還有問題？ok，提供寄生構造函數模式：機器中加個內部機器，這個內部機器負責生產，並生產的的人提供給外部機器，外部機器向外提供這類人就好。（一般用不到吧..）
繼承（我的理解—_—）
問題：女媧要造另一批人B，這批人的模板B造好了，但是想讓這批人有之前造過的那批人的特點，怎麼辦？先讓這些人過濾一下先前的模板A，在放到B中造就ok,這樣類‘B人'就繼承了‘A’類人的特點。如何過濾：父實例=子原型 建B的模板，造一個a出來，這個a肯定要過濾A模板，所以讓B的模板等於a就ok,問題解決。
//父函數，機器A，A類人。它的實例a中有[[Prototype]]屬性和自定義的property屬性
function SuperType(){
this.property=true;
}
//在SuperType原型對象(模具A)中添加getSuperValue方法
SuperType.prototype.getSuperValue=function(){
return this.property
}
//子函數，機器B，B類人。構造函數SubType,它的實例中有[[Prototype]]屬性和自定義的subproperty屬性
function SubType(){
this.subproperty=false;
}
//繼承了SuperType （原型鏈）
SubType.prototype=new SuperType(); //機器B=a
//在SubType原型對象（模具B）中添加getSubValue方法
SubType.prototype.getSubValue=function(){
return tis.subproperty;
}；
var insatance=new SubType();
alert(insatance.getSuperValue()); //true
問題：引用類型值會改變，因為實例共用屬性，和原型模式中的問題相同
解決方案：經典繼承 （借用構造函數）：其實就是把模具A設計到機器B中，但是它已經不是模板了，機器B會給生產的b們添加這些A中的屬性和方法，但是可以人為控制，女媧又命令機器B根據傳遞不同的命令生產不同的b。
在子類構造函數的內部調用超類構造函數
相當於把父類的屬性實例化到子類中？Java中的super（） 存在疑問
function SuperType(){
this.colors=['red','blue','green'];
}
function SubType(){
//繼承了SuperTYpe
SuperType.call(this);
}
var insatance1=new SubType();
insatance1.colors.push('black');
alert(insatance1.colors);// 'red,blue,green,black'
var insatance2=new SubType();
alert(insatance2.colors);//'red,blue,green'
1傳遞參數：
借用構造參數可以在子類型構造參數中向超類型構造參數傳遞參數
function SuperType(name){
this.name=name;
}
function SubType(){
//繼承了SuperTYpe,同時還傳遞了參數
SuperType.call(this，'趙雲');
//實例屬性
this.age=29；
}
var insatance=new SubType();
alert(insatance.name); //趙雲
alert(insatance.age); //29
為了確保SuperType構造函數不會重寫子類型的屬性，可以在調用超類型構造函數之後，再添加應該在子類型中定義的屬性。
問題：浪費勞動力，在機器中創建A具有的功能和屬性，那麼A模板就沒用了，相當於回到工廠模式，都有打火機了，還要鑽木取火嗎....
解決方案：組合繼承
在公司加班沒事做，現在趕著下班，故事編不下去了，後面的繼承模式搬之前的記錄吧..
原型鏈和構造函數技術組合到一起，使用原型鏈實現對原型屬性和方法的繼承，借用構造函數來實現對實例屬性的繼承。這樣通過在原型上定義方法實現了函數的復用，有能夠保證每個實例都有它自己的屬性
原型繼承：方法可以，實例屬性無法繼承； 借用構造函數：實例屬性可以，方法不行。 一起用，完美。
function SuperType(name){
this.name=name;
thi.colors=['red','blue','green'];
}
SuperType.prototype.sayName=function(){
alert(this.name);
};
function SubType(name，age){
//繼承屬性
SuperType.call(this,name);
this.age=age；
}
//繼承方法
SubType.prototype=new SuperType();
SubType.prototype.sayAge=function(){
alert(this.age);
}
var instance1=new SubType('zhaoyun',29);
instance1.colors.push('black');
alert(instance1.colors); //'red,blue,green,black'
instance1.sayName();//zhaoyun
instance1.sayAge();//29
var insatance2=new SubType('諸葛瑾'，25)；
alert(instance2.colrs);'red,blue,green'
instance22.sayName();//諸葛瑾
instance2.sayAge();//25
下班了。。後面的翻看之前的js記錄吧。。趕著回家happy!
