你不知道的JavasScript上篇·第四章·混合對象·類

一、類的理論
1、類的核心概念：多態

• 是說父類的通用行為可以被子類用更特殊的行為重寫

二、類的機制
1、構造函數
類實例是有一個特殊的類方法構造的，這個方法名通常和類名一致；
類構造函數屬於類，構造函數大多需要用new來調。
2、類的多態
其實就是子類可以改寫父類的同名方法也可以調用繼承自父類的同名方法，
任何方法都可以引用繼承層次中高層的方法，無論高層的方法名是否相同。
多態的另一個方面是，在繼承鏈的不同層次中一個方法名可以多次被定義，調用方法時會自動選擇合適的定義。

多態並不表示子類和父類有關聯，子類得到的只是父類的一份副本。
類的繼承其實就是複製。

3、混入
模擬類的複製行為，這個方法就是混入。
混入分為兩種類型：顯示和隱式

• 顯示混入：手動進行複製的。

  下麵例子中 Person.eat.call(this) 就是顯式多態

 function mixin(sourceObj,targetObj){
     for(key in sourceObj){
        console.log(!(key in targetObj))
         //當Person里有，targetObj里沒有的時候才進行複製
         if(!(key in targetObj)){
             targetObj[key] = sourceObj[key]
         }
     }
     return targetObj;
 }
 var Person = {
     sex:'person',
     drink:function(){
         console.log('person要喝水')
     },
     eat:function(){
         console.log('person要吃東西')
     }
 }
 var girl = mixin(Person,{
     sex:'girl',
     eat:function(){
         Person.eat.call(this);
         console.log(this.sex+'要吃東西')
     }
 })
 console.log(girl)
 girl.eat();

運行結果如圖：

複習上篇內容:

"屬性名" in 目標對象：在目標對象上查找屬性名也在原型鏈上也查找
Object.prototype.hasOwnPrototype.call(目標對象,屬性名) 只在目標對象上查找屬性

這裡的
if(!(key in targetObj)){
    targetObj[key] = sourceObj[key]
}
也可以寫成
if(!(Objcet.prototype.hasOwnProperty.call(targetObj,key)){
    targetObj[key] = sourceObj[key]
}
但是因為這裡targetObj和souceObj並沒有繼承關係所以不必用Object.prototype.hasOwnProperty.call()

• 寄生繼承
  寄生繼承是顯式混入模式的一種變體，因為他既是顯式的又是隱式的
  實例：
  

   function Animal(){
       this.type = 'animal'
   }
   Animal.prototype.color = function(){
       console.log("animal's color")
   }
   Animal.prototype.weight = function(){
        this.color();
       console.log("animal's weight")
   }
   function Cat(){
       var cat = new Animal();
       cat.type='cat';
       var anweight = cat.color;
       cat.weight = function(){
           anweight.call(this);
           console.log(this.type+"color" )
       }
       return cat;
   }
   var myCat = new Cat();
   myCat.weight()

• 隱式混入
  

    function Something = {
        cool:function(){
            this.greeting = 'hello world';
            this.count = this.count ? this.count+1 : 1 ;
        }
    }
    Something.cool();
    Something.greeting();
    Something.count;
    var  Another = {
        cool:function(){
        //隱式把Something混入Another
            Something.cool.call(this)
        }
    }
    Another.cool();
    Another.greeting;//hello world
    Another.count;//1

這樣的結構容易搞不清this，對於方法的引用容易出現問題，一般不從採用這種結構

總結：
類是一種設計模式，也意味著複製。
類被繼承時，行為（屬性）也會被覆制到子類中
多態（在繼承鏈的不同層次名稱相同但是功能不同的函數） 看起來似乎是從子類引用父類，但是本質上引用的其實是複製的結果
混入模式可以用來模擬類的複製行為，顯式混入實際上無法完全模擬類的複製行為，因為在Js中對象只能複製引用，無法複製被引用的對象或者函數本身（函數也是對象）