摘要：繼承方式父類構(gòu)造函數(shù)實例方法子類調(diào)用實現(xiàn)父類的構(gòu)造函數(shù)吹呀吹呀，我的驕傲放縱

*前言：上篇文章介紹了js中通過構(gòu)造函數(shù)來實例化對象的各種方法js構(gòu)造函數(shù)，這篇文章主要介紹構(gòu)造函數(shù)的繼承（類的繼承），同樣包括 ES5 和 ES6 兩部分的介紹，能力所限，文中難免有不合理或錯誤的地方，還望各位大神批評指正~

首先簡單介紹一下實例屬性/方法 和 原型屬性/方法，以便更好理解下文

function Persion(name){
    this.name = name;                                       // 屬性
    this.setName = function(nameName){                      // 實例方法
        this.name = newName;
    }
}
Persion.prototype.sex = "man";                              // 向 Persion 原型中追加屬性（原型方法）

var persion = new Persion("張三");                          // 此時我們實例化一個persion對象，看一下name和sex有什么區(qū)別

在控制臺查看 persion 打印如下：

原來通過 prototype 添加的屬性將出現(xiàn)在實例對象的原型鏈中，
每個對象都會有一個內(nèi)置 proto 對象，當(dāng)在當(dāng)前對象中找不到屬性的時候就會在其原型鏈中查找（即原型鏈）

我們再來看下面的例子
注意：在構(gòu)造函數(shù)中，一般很少有數(shù)組形式的引用屬性，大部分情況都是：基本屬性 + 方法。

function Animal(n) {                                       // 聲明一個構(gòu)造函數(shù)
    this.name = n;                                         // 實例屬性
    this.arr = [];                                         // 實例屬性（引用類型）
    this.say = function(){                                 // 實例方法
        return "hello world";
    }
}
Animal.prototype.sing = function() {                       // 追加原型方法  
    return "吹呀吹呀，我的驕傲放縱~~";
}
Animal.prototype.pArr = [];                                // 追加原型屬性（引用類型）

接下來我們看一下實例屬性/方法 和 原型屬性/方法的區(qū)別
原型對象的用途是為每個實例對象存儲共享的方法和屬性，它僅僅是一個普通對象而已。并且所有的實例是共享同一個原型對象，因此有別于實例方法或?qū)傩裕蛯ο髢H有一份。而實例有很多份，且實例屬性和方法是獨立的。

var cat = new Animal("cat");                               // 實例化cat對象
var dog = new Animal("dog");                               // 實例化狗子對象

cat.say === dog.say                                        // false 不同的實例擁有不同的實例屬性/方法
cat.sing === dog.sing                                      // true 不同的實例共享相同的原型屬性/方法

cat.arr.push("zz");                                        // 向cat實例對象的arr中追加元素；（私有）
cat.pArr.push("xx");                                       // 向cat原型對象的pArr中追加元素；（共享）
console.log(dog.arr);                                      // 打印出 []，因為cat只改變了其私有的arr
console.log(dog.pArr);                                     // 打印出 ["xx"], 因為cat改變了與狗子（dog）共享的pArr

當(dāng)然，原型屬性為基本數(shù)據(jù)類型，則不會被共享
在構(gòu)造函數(shù)中：為了屬性(實例基本屬性)的私有性、以及方法(實例引用屬性)的復(fù)用、共享。我們提倡：
1、將屬性封裝在構(gòu)造函數(shù)中
2、將方法定義在原型對象上

首先，我們定義一個Animal父類

function Animal(n) {                              
    this.name = n;                                          // 實例屬性
    this.arr = [];                                          // 實例屬性（引用類型）
    this.say = function(){                                  // 實例方法
        return "hello world";
    }
}
Animal.prototype.sing = function() {                        // 追加原型方法  
    return "吹呀吹呀，我的驕傲放縱~~";
}
Animal.prototype.pArr = [];                                 // 追加原型屬性（引用類型）

function Cat(n) {
    this.cName = n;
}
Cat.prototype = new Animal();                               // 父類的實例作為子類的原型對象

var tom = new Cat("tom");                                   // 此時Tom擁有Cat和Animal的所有實例和原型方法/屬性，實現(xiàn)了繼承
var black = new Cat("black");

tom.arr.push("Im tom");
console.log(black.arr);                                     // 打印出 ["Im tom"], 結(jié)果其方法變成了共享的，而不是每個實例所私有的，這是因為父類的實例方法/屬性變成了子類的原型方法/屬性了；

優(yōu)點: 實現(xiàn)了子對象對父對象的實例 方法/屬性 和 原型方法/屬性 的繼承；
缺點: 子類實例共享了父類構(gòu)造函數(shù)的引用數(shù)據(jù)類型屬性。

function Cat(n) {
    this.cName = n;                     
    Animal.call(this, this.cName);                           // 核心，把父類的實例方法屬性指向子類
}

var tom = new Cat("tom");                                    // 此時Tom擁有Cat和Animal的所有實例和原型方法/屬性，實現(xiàn)了繼承
var black = new Cat("black");

tom.arr.push("Im tom");
console.log(black.arr);                                      // 打印出 [], 其方法和屬性是每個子類實例所私有的；
tom.sing();                                                  // undefind 無法繼承父類的原型屬性及方法；

優(yōu)點:
1、實現(xiàn)了子對象對父對象的實例 方法/屬性 的繼承，每個子類實例所繼承的父類實例方法和屬性都是其私有的；
2、 創(chuàng)建子類實例，可以向父類構(gòu)造函數(shù)傳參數(shù)；
缺點: 子類實例不能繼承父類的構(gòu)造屬性和方法；

function Cat(n) {
this.cName = n;                     
    Animal.call(this, this.cName);                          // 核心，把父類的實例方法屬性指向子類
}
Cat.prototype = new Parent()                                // 核心, 父類的實例作為子類的原型對象
Cat.prototype.constructor = Cat;                            // 修復(fù)子類Cat的構(gòu)造器指向，防止原型鏈的混亂

tom.arr.push("Im tom");
console.log(black.arr);                                     // 打印出 [], 其方法和屬性是每個子類實例所私有的；
tom.sing();                                                 // 打印出 "吹呀吹呀，我的驕傲放縱~~"; 子類繼承了父類的原型方法及屬性

優(yōu)點:
1、創(chuàng)建子類實例，可以向父類構(gòu)造函數(shù)傳參數(shù)；
2、父類的實例方法定義在父類的原型對象上，可以實現(xiàn)方法復(fù)用；
3、不共享父類的構(gòu)造方法及屬性；
缺點: 調(diào)用了2次父類的構(gòu)造方法

function Cat(n) {
this.cName = n;                     
    Animal.call(this, this.cName);                          // 核心，把父類的實例方法屬性指向子類
}
Cat.prototype = Parent.prototype;                           // 核心, 將父類原型賦值給子類原型（子類原型和父類原型，實質(zhì)上是同一個）
Cat.prototype.constructor = Cat;                            // 修復(fù)子類Cat的構(gòu)造器指向，防止原型鏈的混亂

tom.arr.push("Im tom");
console.log(black.arr);                                     // 打印出 [], 其方法和屬性是每個子類實例所私有的；
tom.sing();                                                 // 打印出 "吹呀吹呀，我的驕傲放縱~~"; 子類繼承了父類的原型方法及屬性
tom.pArr.push("publish");                                   // 修改繼承于父類原型屬性值 pArr;
console.log(black.pArr);                                    // 打印出 ["publish"], 父類的原型屬性/方法 依舊是共享的，
// 至此簡直是完美呀~~~ 然鵝！
Cat.prototype.childrenProp = "我是子類的原型屬性！";
var parent = new Animal("父類");
console.log(parent.childrenProp);                           // 打印出"我是子類的原型屬性！" what? 父類實例化的對象擁有子類的原型屬性/方法，這是因為父類和子類使用了同一個原型

優(yōu)點:
1、創(chuàng)建子類實例，可以向父類構(gòu)造函數(shù)傳參數(shù)；
2、子類的實例不共享父類的構(gòu)造方法及屬性；
3、只調(diào)用了1次父類的構(gòu)造方法；
缺點: 父類和子類使用了同一個原型，導(dǎo)致子類的原型修改會影響父類；

function Cat(n) {
this.cName = n;                     
    Animal.call(this, this.cName);                          // 核心，把父類的實例方法屬性指向子類；
}
var F = function(){};                                       // 核心，利用空對象作為中介；
F.prototype = Parent.prototype;                             // 核心，將父類的原型賦值給空對象F；
Cat.prototype = new F();                                    // 核心，將F的實例賦值給子類；
Cat.prototype.constructor = Cat;                            // 修復(fù)子類Cat的構(gòu)造器指向，防止原型鏈的混亂；
tom.arr.push("Im tom");
console.log(black.arr);                                     // 打印出 [], 其方法和屬性是每個子類實例所私有的；
tom.sing();                                                 // 打印出 "吹呀吹呀，我的驕傲放縱~~"; 子類繼承了父類的原型方法及屬性；
tom.pArr.push("publish");                                   // 修改繼承于父類原型屬性值 pArr；
console.log(black.pArr);                                    // 打印出 ["publish"], 父類的原型屬性/方法 依舊是共享的；
Cat.prototype.childrenProp = "我是子類的原型屬性！";
var parent = new Animal("父類");
console.log(parent.childrenProp);                           // undefind  父類實例化的對象不擁有子類的原型屬性/方法；

優(yōu)點: 完美實現(xiàn)繼承；
缺點:實現(xiàn)相對復(fù)雜

function extend(Child, Parent) {
    var F = function(){};
    F.prototype = Parent.prototype;
    hild.prototype = new F();
    Child.prototype.constructor = Child;
    Child.uber = Parent.prototype;                          
}
// 使用
extend(Cat,Animal);

Child.uber = Parent.prototype; 的意思是為子對象設(shè)一個uber屬性，這個屬性直接指向父對象的prototype屬性。（uber是一個德語詞，意思是"向上"、"上一層"。）這等于在子對象上打開一條通道，可以直接調(diào)用父對象的方法。這一行放在這里，只是為了實現(xiàn)繼承的完備性，純屬備用性質(zhì)。

class Animal{                                                // 父類
    constructor(name){                                       // 構(gòu)造函數(shù)
        this.name=name;
    }
    eat(){                                                   // 實例方法
        return "hello world";
    }
}
class Cat extends Animal{                                    // 子類
  constructor(name){
      super(name);                                           // 調(diào)用實現(xiàn)父類的構(gòu)造函數(shù)
      this.pName = name;            
  }
  sing(){
     return "吹呀吹呀，我的驕傲放縱~~";
  }
}