JS实现继承的7种方式

父类

function Person(name) { 
    this.name = name;
    this.sum = function() {
        alert(this.name);
    }
}
Person.prototype.age = 10;

一、原型链继承

function Per_pro(name) {
    this.name = name;
}
Per_pro.prototype = new Person();
var Per_pro = new Per_pro();
console.log(Per_pro.age);
console.log(Per_pro instanceof Person);

重点：让新实例的原型等于父类的实例。
特点：1、实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性（新实例不会继承父类其他实例的属性！）。
缺点： 1、新实例无法向父类构造函数传参；
    2、继承单一；
    3、所有新实例都会共享父类实例的属性。（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）。

二、借用构造函数

function Per_con() {
    Person.call(this, 'hyy');
    this.age = 12;
}
var per_con = new Per_con();
console.log(per_con.name);
console.log(per_con.age);
console.log(per_con instanceof Person)

重点：用.call()和.apply()将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））。
特点：1、只继承了父类构造函数的属性，没有继承父类原型的属性；
    2、解决了原型链继承缺点1、2、3；
    3、可以继承多个构造函数属性（call多个）；
    4、在子实例中可向父实例传参。
缺点：1、只能继承父类构造函数的属性；
   2、无法实现构造函数的复用（每次用都要重新调用）；
   3、每个新实例都有父类构造函数的副本，臃肿。

组合继承（常用）

function SunType(name) {
    Person.call(this, name); // 借用构造函数
}
SunType.prototype = new Person(); // 原型链继承
var suntype = new SunType('hyy');
console.log(suntype.name); // 继承了构造函数属性
console.log(suntype.age); // 继承了父类原型属性

重点：结合了两种模式的优点，传参和复用。
特点：1、可以继承父类原型上的属性，可以传参，可复用；
   2、每个新实例引入的构造函数属性是私有的。
缺点：调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数。

原型式继承

// 先封装一个函数容器，用来输出对象和承载继承的原型
function content(obj) {
    function F() {}
    F.prototype = obj; // 继承了传入的参数
    return new F(); // 反回函数对象
}
var sup = new Person(); // 创建父类函数的实例
var sup1 = content(sup);
console.log(sup1.age); // 继承了父类函数的属性

重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对，object.create()就是这个原理。
特点：类似于复制一个对象，用函数来包装。
缺点：1、所有实例都会继承原型上的属性；
   2、无法实现复用（新实例属性都是后面添加的）。

寄生式继承

function content(obj) {
    function F() {}
    F.prototype = obj; // 继承了传入的参数
    return new F(); // 反回函数对象
}
var sup = new Person();
// 以上是原型式继承，给原型式继承再套个壳子传递参数
function SubObject(obj) {
    var sub = content(obj);
    sub.name = 'hyy';
    return sub;
}
var sup2 = new SubObject(sup);
// 这个函数经过声明之后就成了可增添属性的对象
console.log(typeof SubObject); // function
console.log(typeof sup2); // object
console.log(sup2.name); // hyy, 继承了sub属性

重点：就是给原型式继承外面套了个壳子。
优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。
缺点：没用到原型，无法复用。

寄生组合式继承

function content(obj) {
    function F() {}
    F.prototype = obj; // 继承了传入的参数
    return new F(); // 反回函数对象
}
// content 就是F实例的另一种写法
var con = content(Person.prototype);
// con 实例（F实例）的原型继承了父类函数的原型；
// 上述更像是原型链继承，只不过只继承了原型属性
// 组合
function Sub() {
    Person.call(this); // 继承了父类构造函数的属性
} // 解决了组合式继承两次调用构造函数的缺点
// 重点
Sub.prototype = con; // 继承了con实例
con.constructor = Sub; // 一定要修复实例
var sub1 = new Sub();
// Sub的实例就继承了构造函数的属性，父类的实例，con函数的属性
console.log(sub1.age); // 10

重点：修复了组合继承的问题。

extends实现继承

1、把子类构造函数(Child)的原型（`__proto__`）指向父类构造函数（Parent）
2、把子类实例child的原型对象（child.prototype）的原型(__proto__)执行父类的原型对象(parent.prototype)
3、子类构造函数使用`super`继承父类构造函数属性
ps: new 做了什么？
（1）创建一个新对象；
（2）将构造函数的作用域赋给新对象（因此this就指向了这个新对象）；
（3）执行构造函数中的代码（为这个新对象添加属性）；
（4）返回新对象。

class Parent {
  constructor(name){
    this.name = name;
    static sayHello(){
        console.log(this.name)
    }
  }
}

class Child extends Parent {
  constructor(name, age){
    super(name);
    this.age = age;
  }
  sayAge(){
    console.log(this.age)
    return this.age;
  }
}
let parent = new Parent("Parent");
let child = new Child("Child", 18);