實現繼承的幾種方式以及他們的優缺點

實現繼承的幾種方式以及他們的優缺點（參考文檔1、參考文檔2、參考文檔3）

　　要搞懂JS繼承，我們首先要理解原型鏈：每一個實例對象都有一個__proto__屬性（隱式原型），在js內部用來查找原型鏈；每一個構造函數都有prototype屬性（顯示原型），用來顯示修改對象的原型，實例.__proto__=構造函數.prototype=原型。原型鏈的特點就是：通過實例.__proto__查找原型上的屬性，從子類一直向上查找對象原型的屬性，繼而形成一個查找鏈即原型鏈。 

　　1）原型鏈繼承：

　　我們使用原型繼承時，主要利用sub.prototype=new super，這樣連通了子類-子類原型-父類。

　　核心：將父類的實例作為子類的原型。

//父類，帶屬性  
function Super(){  
    this.flag = true;  
}  
//為了提高復用性，方法綁定在父類原型屬性上  
Super.prototype.getFlag = function(){  
    return this.flag;  
}  
//來個子類  
function Sub(){  
    this.subFlag = false;  
}  
//實現繼承  
Sub.prototype = new Super;  
//給子類添加子類特有的方法，注意順序要在繼承之后  
Sub.prototype.getSubFlag = function(){  
    return this.subFlag;  
}  
//構造實例  
var es5 = new Sub;  

　　特點：

　　1. 非常純粹的繼承關系，實例是子類的實例，也是父類的實例

　　2. 父類新增原型方法/原型屬性，子類都能訪問到

　　缺點：

　　來自原型對象的引用屬性是所有實例共享的，即屬性沒有私有化，原型上屬性的改變會作用到所有的實例上。

　　2）構造函數繼承：

　　在構造子類構造函數時內部使用call或apply來調用父類的構造函數

　　核心：使用父類的的構造函數來增強子類實例，等於是復制父類的實例屬性給子類（沒用到原型）

function Super(){  
    this.flag = true;  
}  
function Sub(){  
    Super.call(this)  //如果父類可以需要接收參數，這里也可以直接傳遞  
}  
var obj = new Sub();  
obj.flag = flase;  
var obj_2 = new Sub();  
console.log(obj_2.flag)  //依然是true，不會相互影響  

　　優缺點：實現了屬性的私有化，但是子類無法訪問父類原型上的屬性。

　　特點：
　　1. 解決了1中，子類實例共享父類引用屬性的問題
　　2. 創建子類實例時，可以向父類傳遞參數
　　3. 可以實現多繼承（call多個父類對象）
　　缺點：
　　1. 實例並不是父類的實例，只是子類的實例
　　2. 只能繼承父類的實例屬性和方法，不能繼承原型屬性/方法
　　3. 無法實現函數復用，每個子類都有父類實例函數的副本，影響性能

　　3）組合繼承：

　　利用構造函數和原型鏈的方法，可以比較完美的實現繼承

function Super(){  
    this.flag = true;  
}  
Super.prototype.getFlag = function(){  
    return this.flag;     // 繼承方法  
}  
function Sub(){  
    this.subFlag = flase  
    Super.call(this)    // 繼承屬性  
}  
Sub.prototype = new Super;  
var obj = new Sub();  
// Sub.prototype = new Super; 會導致Sub.prototype的constructor指向Super;
// 然而constructor的定義是要指向原型屬性對應的構造函數的，Sub.prototype是Sub構造函數的原型，
// 所以應該添加一句糾正：Sub.prototype.constructor = Sub;
Sub.prototype.constructor = Sub;  // 修復構造函數指向
Super.prototype.getSubFlag = function(){  
    return this.flag;  
}  

　　特點：
　　1. 彌補了方式2的缺陷，可以繼承實例屬性/方法，也可以繼承原型屬性/方法
　　2. 既是子類的實例，也是父類的實例
　　3. 不存在引用屬性共享問題
　　4. 可傳參
　　5. 函數可復用
　　缺點：
　　1. 調用了兩次父類構造函數，生成了兩份實例（子類實例將子類原型上的那份屏蔽了）

 　　4）寄生繼承：

　　核心：通過寄生方式，砍掉父類的實例屬性，這樣，在調用兩次父類的構造的時候，就不會初始化兩次實例方法/屬性，避免的組合繼承的缺點

　　example1：

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 創建一個沒有實例方法的類
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //將實例作為子類的原型
  Cat.prototype = new Super();
})();
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true
Cat.prototype.constructor = Cat; // 需要修復下構造函數

　　example2：

 

　　特點：使用到了Object.create(Fu.prototype)實現原型鏈的淺拷貝
　　優點：解決了原型鏈繼承和構造函數繼承的缺點