摘要：通常有這兩種繼承方式接口繼承和實現(xiàn)繼承。理解繼承的工作是通過調(diào)用函數(shù)實現(xiàn)的，所以是寄生，將繼承工作寄托給別人做，自己只是做增強工作。適用基于某個對象或某些信息來創(chuàng)建對象，而不考慮自定義類型和構(gòu)造函數(shù)。

繼承，是面向?qū)ο笳Z言的一個重要概念。
通常有這兩種繼承方式：接口繼承和實現(xiàn)繼承。接口繼承只繼承方法簽名，而實現(xiàn)繼承則繼承實際的方法。

《JS高程》里提到：“由于函數(shù)沒有簽名，在‘ECMAScript’中無法實現(xiàn)接口繼承?！?/pre>
等等，函數(shù)簽名是什么東西？據(jù)MDN文檔定義如下：
函數(shù)簽名（類型簽名、方法簽名）定義了函數(shù)或方法的輸入與輸出。
簽名可包含以下內(nèi)容：

參數(shù) 及參數(shù)的 類型
一個的返回值及其類型
可能會拋出或傳回的異常
該方法在 面向?qū)ο蟪绦蛑械目捎眯苑矫娴男畔ⅲㄈ鏿ublic、static或prototype）。


看起來好復(fù)雜啊，我們換成強類型的語言的角度會不會更好理解？
譬如，C的函數(shù)簽名就是我們熟悉的函數(shù)聲明：
int func(double d);
此時：參數(shù)名為d，參數(shù)類型為double，返回值為func(d)，返回值類型為int。
再如，Java的函數(shù)簽名：
public static void main(String[] args)
此時：參數(shù)名為args，參數(shù)類型為String []，返回值類型為void所以該方法沒有返回值，訪問修飾符public表示該方法是公有方法，static表示該方法是一個類方法而非實例方法……
現(xiàn)在，我們知道函數(shù)簽名是怎么回事了。那么，接口繼承又是什么東西？相信大家會遙想起Java中的interface，implements等……在此就不班門弄斧了。
我們知道，JavaScript是類型松散的語言，不像Java它們有嚴(yán)格的變量類型檢查。所以，JS的函數(shù)才沒有簽名，才無法實現(xiàn)接口繼承。
那么，JS的實現(xiàn)繼承是怎么回事呢？
二、JS的繼承


原型鏈的基本模式
  理解：通過創(chuàng)建SuperType的實例，并將該實例賦給SubType.prototype，來實現(xiàn)SubType繼承SuperType。instance的原型指向SubType，SubType的原型指向SuperType，SuperType的原型指向Object，如此構(gòu)成了原型鏈。
  缺點：對象實例共享所有繼承的屬性和方法，不適宜多帶帶適用
function SuperType() {
    this.property = true;
}
SuperType.prototype.getSuperValue = function() {
    return this.property;
};
function SubType() {
  this.subproperty = false;
}
//SubType繼承SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function() {
  return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue());  //true
于是，有下一個招式，來解決包含引用類型值的原型屬性會被所有實例共享的弱點。


借用構(gòu)造函數(shù)
  理解：“借用”超類型構(gòu)造方法，在新的子類型對象上執(zhí)行超類型函數(shù)定義的所有對象初始化代碼
  適用：解決超類型的引用類型值被所有子類型對象實例共享，而且子類型可向超類型傳參
  缺點：不能做到函數(shù)復(fù)用，從而降低效率，不適宜多帶帶適用
function SuperType(name) {
  this.name = name;
  this.colors = ["red", "blue", "green"]; //引用類型值
}
function SubType() {
  SuperType.call(this, "A"); //繼承SuperType “借用”超類型的構(gòu)造函數(shù) 并傳參
  this.age = 20;    //實例屬性
}
var instance1 = new SubType();    //instance1.name: "A", instance1.age: 20
instance1.colors.push("black"); //instance1.colors: "red, blue, green, black"
var instance2 = new SubType();  //instance2.colors: "red, blue, green"
接下來，組合技能出大招！


組合繼承
  理解：將原型鏈和借用構(gòu)造函數(shù)組合到一起，通過原型鏈來繼承共享的原型屬性和方法，通過借用構(gòu)造函數(shù)來繼承實例屬性。
  適用：最常用的繼承模式。
  缺點：調(diào)用兩次超類型構(gòu)造函數(shù)，在SubType上創(chuàng)建了多余的屬性，造成超類型對象的實例屬性的重寫
function SuperType(name) {
  this.name = name;
  this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function() {
  alert(this.name);
};
function SubType(name, age) {
  SuperType.call(this, name);   //繼承屬性 第二次調(diào)用超類型構(gòu)造函數(shù) 新實例得到兩個實例屬性name,colors
  this.age = age;
}
SubType.prototype = new SuperType();  //繼承方法 第一次調(diào)用超類型構(gòu)造函數(shù) SubType.prototype得到兩個實例屬性name,colors
SubType.prototype.sayAge = function() {
  alert(this.age);
};

var instance1 = new SubType("妹妹", 18);
instance1.colors.push("black");
alert(instance1.colors);  //"red, blue, green, black"
instance1.sayName();  //"妹妹"
instance1.sayAge();  //18

var instance2 = new SubType("弟弟", 20);
alert(instance2.colors);  //"red, blue, green"
instance2.sayName();  //"弟弟"
instance2.sayAge();  //20
這是打boss的大招，那我怎么對付小怪？


原型式繼承
  理解：本質(zhì)是對給定對象的淺復(fù)制
  適用：不必預(yù)先定義構(gòu)造函數(shù)來實現(xiàn)繼承，只想讓一個對象與另一個對象保持類似
  缺點：引用類型值的屬性被共享，如同原型模式一樣
function object(o) {    //對o進行淺復(fù)制
  function F() {}    //創(chuàng)建一個臨時性的構(gòu)造函數(shù)
  F.prototype = o;    //將傳入的對象o作為F的原型
  return new F();    //返回F的新實例
}

var person = {
  name: "A",
  friends: ["B", "C", "D"]
};
var anotherPerson = object(person);    // Object.create(person)
anotherPerson.name = "E";
anotherPerson.friends.push("F");
var yetAnotherPerson = object(person);    //Object.create(person)
yetAnotherPerson.name = "G";
yetAnotherPerson.friends.push("H");
alert(person.friends);  //"B, C, D, F, H" 引用類型值的屬性被共享啦
注意：Object.create()方法的第二個參數(shù)，新對象的額外屬性的對象，會覆蓋原型對象上的同名屬性。
var anotherPerson = Object.create(person, {
  name: { value: "E" }
});
alert(anotherPerson.name);   // "E"
打了這么久，能不能讓小招也升級（封裝）一下啊？


寄生式繼承
創(chuàng)建一個僅用于封裝繼承過程的函數(shù)，該函數(shù)在內(nèi)部以某種方式來增強對象，最后再像真的是它做了所有工作一樣返回對象。
理解：繼承的工作是通過調(diào)用函數(shù)實現(xiàn)的，所以是“寄生”，將繼承工作寄托給別人做，自己只是做增強工作。
 適用：基于某個對象或某些信息來創(chuàng)建對象，而不考慮自定義類型和構(gòu)造函數(shù)。
 缺點：不能做到函數(shù)復(fù)用，從而降低效率
 function createAnother(original) {
   var clone = object(original); //通過調(diào)用函數(shù)創(chuàng)建一個新對象
   clone.sayHi = function() {  //以某種方式來增強這個對象
     alert("hi");
   }
   return clone;
 }
 var person = {
   name: "A",
   friends: ["B", "C", "D"]
 };
 var anotherPerson = createAnother(person);  //不僅有person所有屬性方法，還有自己的sayHi方法
 anotherPerson.sayHi();  //"hi"
經(jīng)驗攢足，我要把之前打boos的組合大招升到滿級！


寄生組合繼承
  理解：通過借用構(gòu)造函數(shù)來繼承屬性，通過原型鏈的混用形式來繼承方法。用寄生式繼承來繼承超類型的原型，再將增強后的結(jié)果指定給子類型的原型。
  適用：引用類型最理想的繼承模式，高效，只調(diào)用了一個SuperType構(gòu)造函數(shù)
function inheritPrototype(subType, superType) {
  var prototype = object(superType.prototype); //創(chuàng)建對象 超類型原型的副本
  prototype.constructor = subType;  //增強對象 彌補因重寫原型而失去默認(rèn)的constructor屬性
  subType.prototype = prototype;  //指定對象
}

function SuperType(name) {
  this.name = name;
  this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function() {
  alert(this.name);
};
function SubType(name, age) {
  SuperType.call(this, name);   //繼承屬性
  this.age = age;
}
inheritPrototype(SubType, SuperType);  //繼承方法
SubType.prototype.sayAge = function() {
  alert(this.age);
};


三、ES6的繼承
extends關(guān)鍵字用來創(chuàng)建一個普通類或者內(nèi)建對象的子類。
class A {
    ...
}
class B extends A {
    ...
}
其中，
B.__proto__ === A // true
B.prototype.__proto__ === A.prototype // true
因為extends實現(xiàn)了：
Object.setPrototypeOf(B.prototype, A.prototype);    //B.prototype.__proto__ = A.prototype;

Object.setPrototypeOf(B, A);    //B.__proto__ = A
extends更具體的實現(xiàn)方法參見面試官問：JS的繼承，在此就不班門弄斧了~

完~若有不足，請多指教，不勝感激！
以上代碼借鑒于《JS高級程序設(shè)計》