JS中的继承方式：

1.1 原型链继承

• 原型继承： 将子类B的原型对象 重写成父类A的一个实例。

B.prototype = new A();
把父类共有属性和私有属性变成子类的公有属性

function A() {
}
A.prototype.age = 19;
A.prototype.say = function () {
   console.log('来自A类原型的say方法')
};
function B() {}
B.prototype = new A();  //把B类的原型改写成一个A类的实例；
let b = new B();
console.log(b);
console.log(b.__proto__);  {text: 'xxx', __proto__....}
console.log(b.age);
console.log(b.say);

把B的原型改写成A类的一个实例，此时通过 b.age 访问b的age属性，首先在私有属性中查找，私有属性中没有age属性，接着去b所属类的原型（B.prototype）上查找，此时原型对象是A的实例对象，在原型对象也没有age属性，然后通过原型对象的proto就找到了A.prototype上，A的prototype上有age属性

• 原型继承是把子类公有的属性和私有的属性都变成了子类私有的属性；
• 缺点：改写子类的原型对象，会导致子类原型对象上的constructor属性被改写，需要重新指定继承后的constructor；

1.2 借用构造函数继承

借用构造函数：把父类当做普通函数，在子类的函数体中call执行父类的函数；

function A() {
   this.a = 'aa';
   this.say = function () {
      console.log('A say');
   }
}
A.prototype.public = 'public';
function B() {
   A.call(this);  //this是B类的一个实例，A.call(this) 的意思是把A中的this就该成B的实例（而在B的构造函数中this就是B的实例）这样在A中通过this.xxx = xxx 的方式添加的属性都会添加到B的实例身上。
}
let b = new B();
console.log(b);  {a: 'aa', say: fun.....}
let b2 = new B();
console.log(b2.say === b.say);  false;

借用构造函数继承：

• 把父类当做普通函数，在子类的函数体里面，通过call方法执行 A.call(this)
• call方法是用来修改this指向的，这样一来就把A中的this修改成了b的实例；在函数A中通过this.xxx = xxx 添加的属性都添加到了B的实例身上；
• 特点：只能把父类的私有属性和方法继承为子类的私有属性和方法；

.3 组合继承

组合继承：原型链继承 + 借用构造函数继承

• 原型链继承：把父类私有的和共有的继承为子类公有的；
• 借用构造函数继承：把父类私有的继承为子类私有的

   this.a = '私有的'
}
A.prototype.text = '公有';
A.prototype.say = function () {
   console.log('A公有的say方法')
};
function B() {
   A.call(this);  //借用构造函数继承，继承父类私有的
}
B.prototype = new A();  //原型链继承，继承父类私有和公有的属性；
B.prototype.constructor = B;
let b = new B();
console.log(b.text);  公有的
console.log(b.a);  私有的

• 组合继承也并非没有缺点，组合继承会把父类的私有继承两次，一份在借用构造函数继承时成为私有的，而另一份是在原型继承时成为公有的；

1.4 原型式继承

原型式继承：把父类的公有属性继承为子类的公有属性；

创建一个新的对象，并且新对象的proto指向A.prototype，最后把这个新对象作为B类的原型；

• 创建一个对象，并且对象的proto 指向obj

Object.create(obj)

• 原型式继承示例

function A() {
   this.private = 'private私有';
}
A.prototype.public = 'public公有';
function B() {}
B.prototype = Object.create(A.prototype); // 创建一个指定原型的对象 创建一个对象，并且这个对象的__proto__ 指向A.prototype
B.prototype.constructor = B; // 原型式继承同样是修改B类原型的指向，所以需要重新指定构造函数
let b = new B();
console.log(b.public);

1.5 寄生组合式继承

• 寄生组合式继承：原型式继承 + 借用构造函数继承

function A() {
   this.private = '私有属性';
}
A.prototype.public = '公有属性';
function B() {
   A.call(this);  //借用构造函数继承
   this.name = 'b私有的';
}
 //原型式继承：把父类公有的 继承为子类实例公有的
B.prototype = Object.create(A.prototype);
B.prototype.constructor = B;
let b = new B();  {name: '私有的', private: '私有属性'}
console.log(b.private);  //继承过来的私有属性
console.log(b.public);  //继承过来到的公有属性

1.6 冒充对象继承

冒充对象继承：在子类的构造函数中生成一个父类的实例，把父类的这个实例进行遍历，把属性都添加子类的实例上；

function A() {
   this.private = '私有属性';
}
A.prototype.public = '公有属性';
function B() {
   this.name = 'B私有的属性';
   let tmp = new A();
   for (let key in tmp) {
      this[key] = tmp[key];
   }
}
let b = new B();
console.log(b);

1.7 ES6中的类

ES5 一个函数就是一个类
ES6 借鉴后端语言，增加了class关键字，创建一个类

• ES5

function Teacher(name, age, subject) {
   this.name = name;
   this.age = age;
   this.subject = subject;
}
Teacher.motor = '传道';
Teacher.prototype.teach = function () {
   console.log(this.name + this.age);
};
let t = new Teacher('mabin', 19, 'js');

• ES6

class Teacher {
   constructor (name, age, subject) {
       //这里面通过this.xxx = xxx 是给实例添加私有属性
      this.name = name;
      this.age = age;
      this.subject = subject;
   }
    //添加公有属性
   teach () {
      console.log(this.name + this.age + this.subject);
   }
   // 添加静态方法
   static motor = '传授知识';
   static getMotor () {
      console.log('We are family');
   }
}
let t = new Teacher('马宾宾', 21, 'HTML');
t.teach(); //马宾宾21HTML
console.log(Teacher.motor); //传授知识
Teacher.getMotor(); //We are family

1.7 ES6继承

ES6继承：extends关键字

class A {
   constructor (name, age) {
      this.name = name;
      this.age = age;
   }
    //公有方法（添加到原型上）
   say () {
      console.log(`${this.name} say`);
   }
}
 //ES6继承时使用 extends 关键字实现继承
class B extends A {  //B继承A类
   constructor (x, y, forName, forAge) {
       //注意：在使用ES6的extends关键字之前，必须使用super(); super表示父类的构造函数
      super(forName, forAge);  
      this.x = x;
      this.y = y;
   }
}
let b = new B('x', 'y', 'mabin', 18);
console.log(b); //{name: "mabin", age: 18, x: "x", y: "y"}
b.say(); //来自A类原型的say方法

• ES6的继承原理是：寄生组合式继承