JAVASCRIPT 物件的創作與6種繼承模式的理解與遐想

JS中總共有六種繼承模式，包括原型鏈、借用建構子、組合繼承、原型式繼承寄生式繼承、寄生組合式繼承。為了方便理解記憶，我遐想了一個過程，對6中模式做了簡單的闡述。

　　很長的一個故事，姑且取個名字叫女媧造人吧。

 

　　創建對象

　　女媧一個一個的捏人（創建對象），這樣，於是設計了一種機器（函數），想造什麼樣的，告訴他這個人有哪些特點和功能太慢，於是設計了一種機器（函數），想造什麼樣的，告訴他這個人有哪些特點和功能太慢，機器來製造。這就是工廠模式的（使用同一個介面創建對象，回產生大量重複程式碼，由此發明了一種函數（模具））。

    但是機器造人同樣也比較麻煩（挖土、和泥、捏眼睛、捏鼻子...）於是封裝的思想來了，鼻子眼睛什麼的提前捏好備用，改造機器，告訴要造的人具有什麼樣的眼睛，鼻子，機器可以直接拿來安裝ok,這樣的機器就是構造函數。

　 這樣仍然存在問題，假設要讓捏的人都能跑，就要機器給每個人安裝一個'跑'的功能，這樣工序太慢，還可能出錯，找第三方吧（函數方法定義到構造函數外部，全域作用域中）。第三方負責給我把捏的人都裝上跑的功能，我拿來再放到機器上用，省的每次都加工。 ok,人都能跑了，很方便，但是問題又出現了，造的人還需要'跳'、'走'..的N個功能，總不能再找N個第三方吧，那這樣建機器就沒意義了。於是女媧（開發人員）早創造了原型模式...厲害了我的媧。

　　原型模式中每個函數都有一個prototype屬性，是指針，指向原型物件。原型物件包含能讓所有實例共享的屬性和方法，這個原型物件有一個constructor屬性，這個屬性包含一個指向prototype屬性所在函數的指標。

　　看似有點繞，從女媧這個角度就好理解了：造物主女媧娘娘還發明了個各種各樣的模具（原型對象），要開始造了：1造一類人-->用的是造這類人的模具。　　畢竟可以造萬物，造什麼用什麼樣的模具。所有造人機器（函數）都有各自唯一的一個模具（原型物件），並且機器有一個標籤[prototype],指向模具，這個模具有能貼生產標誌的[constructor]屬性，指向這個機器，表示是這個機器的模俱生產。因此要造什麼樣的一類人，只要改模具就好了。這就是原型物件的好處，方便，快速。

　　生產過程如下： 1造機器A ：function  jqA(){}; //有個prototype屬性，指向模具(原型物件)

　　　　　　模具　　　　　　　　　　constructor: jqA, //相當於貼上標籤，由A機器生產,

　　　　　　　　　　　　name:'lily',

　　　　　　

　　　　　　　　　　　　run: function(){

　　　　　　》　　　　　　　　〜　　　〜　〜〜] }

　　　　　　　　　　 這個模具負責造名字叫lili,皮膚為white,能run的這類人。

　　　　　　　　　　3  造一個這類型的人   var person1=new jqA();🎀『 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