原来JS可以这么实现继承

当我们在编写代码的时候，有一些对象内部会有一些方法（函数），如果将这些函数在构造函数内部声明会导致内存的浪费，因为实例化构造函数得到不同的实例对象，其内部都有同一个方法，但是占据了不同的内存，就存在内存浪费问题。于是乎我们就需要用到继承。

什么是继承？

通过某种方式让一个对象可以访问到另一个对象中属性和方法，我们将这种方法称之为继承（inheritance）。

如果一个类B继承自另一个类A，就把B称之为A的子类，A称之为B的父类或者超类。

如何实现继承？

1、原型链继承

// 原型链的继承
SuperType.prototype.getSuperValue = function () {
return this.property;

}
function SuperType() {
this.property = true

}

Type.prototype = new SuperType();

function Type() {
this.typeproperty = false

}

console.log(Type.prototype);

var instance = new Type()

console.log(instance.getSuperValue());  // true

让SuperType的实例对象赋给Type的原型，Type就能继承到SuperType的属性和方法

优点：原型链继承容易上手，书写简单，父类可以复用，被多个子类继承。

缺点：会在子类实例对象上共享父类所有的引用类型实例属性，（子类改不动父类的原始类型），更改一个子类的引用属性，其他子类均受影响；子类不能改父类传参。

2、经典继承（伪造对象）

// 经典继承
SuperType.prototype.name = '寒月十九'

function SuperType(age) {
this.color = ['red', 'green', 'blue'],
this.age = age

}

function Type(age) {
SuperType.call(this,age)

}

var instance = new Type(18)
console.log(instance);
console.log(instance.color);

经典继承就是借助this的显示绑定，将SuperType的指向绑定到Type身上，使得我们可以直接访问到SuperType身上的属性。

优点：解决了原型链继承子类不能向父类传参的问题和原型共享的问题。

缺点：方法不能复用；子类继承不到父类原型上的属性，只能继承到父类实例对象上的属性。

3、组合继承(原型链继承 + 经典继承)

// 组合继承 (伪经典继承)
SuperType.prototype.sayName =function() {
console.log(this.name);

}

function SuperType(name) {
this.name = name,
this.color = ['red', 'green', 'blue']

}
function Type(age,name) {
this.age = age
SuperType.call(this,name)

}

Type.prototype = new SuperType()
Type.prototype.constructor = Type  

//Type.prototype被替换了，所以要补充一个constructor属性，指向自身，这样new Type得到的实例对象就有constructor属性

Type.prototype.sayAge = function() {
console.log(this.age)

}

var instance = new Type(20,'寒月十九');

instance.sayAge();

组合继承就是将上面两种继承方式结合起来，先将SuperType的this指向显示绑定到Type，然后再替换Type的原型，再添加上构造器属性指向自身，使得new Type()得到的实例对象就具备构造属性，并且可以继承到SuperType的属性。

优点：解决了原型链继承和经典继承的缺点造成的影响。

缺点：每一次都会调用两次父类的构造函数，一次是在创建子类原型上，另一次是在子类构造函数内部。

4、原型式继承

（1）借助构造函数实现对象的继承

// 原型式继承
function object(obj) {
function newFn() {}

  newFn.prototype = obj;
return new newFn();

};
var person = {
name: '寒月十九',
age: 20,
like: {
sport: 'coding'

  }

};
let newObj = object(person);

（2）Object.create()

var person = {

  name: '寒月十九',

  age: 20,

  like: {

    sport: 'coding'

  }

};

let newPerson = Object.create(person,{sex: 'boy'});

优点：不需要单独构建构造函数。

缺点：属性中的引用地址会在相关对象中共享。

5、寄生式继承

function createPerson(original) {
var clone = Object.create(original)

  clone.say = function() {  // 增强这个对像
console.log('hello');

  }
return clone;

};
var person = {
name: '寒月十九',
age: 20,
like: {
sport: 'coding'

  }

};
let newPerson =createPerson(person);

寄生式继承是原型式继承的加强版，它结合原型式继承和工厂模式，创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后返回对象。

优点：上手简单，不用单独创建构造函数。

缺点：寄生式继承给对象添加函数会导致函数难以重用，因此不能做到函数复用而效率降低；引用类型的属性始终都会被继承所共享。

寄生组合式继承

// 寄生组合式继承
SuperType.prototype.sayName = function() {

  console.log(this.name);

};
SuperType.prototype.like = {

  a: 1,

  b: 2

};

function SuperType(name) {
this.name = name;
this.colors = ['red', 'blue', 'green']

};


function Type(name, age) {
this.age = age;

  SuperType.call(this, name);

}


var anotherPrototype = Object.assign(Type.prototype, SuperType.prototype);

// anotherPrototype.constructor = Type

Type.prototype = anotherPrototype; // new SuperType()

寄生组合继承是为降低父类构造函数的开销。通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

优点：高效，只调用一个次父构造函数，不会在原型上添加多余的属性，原型链还能保持不变；开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。

缺点：代码较复杂。

class类继承

class Parent{
constructor(name) {
this.name = name;
this.hobbies = ["running", "basketball", "writting"];

  }
getHobbies() {
return this.hobbies;

  }
static getCurrent() {  // 静态方法，只能类本身调用
console.log(this);

  }

}

class Child extends Parent {
constructor(name) {
super(name);

  }

}

var c1 = new Child('寒月十九');
var c2 = new Child('十九');