JS中常见的几种继承

1原型链继承

子类构造函数.prototype = 父类的实例; 子类构造函数.prototype.constructor = 子类构造函数
特点:
1.js继承是把父类的原型放到子类的原型链上,实例想要调用这些方法,其实是基于__proto__原型链的机制查找完成的
2.子类可以重写父类上的属性和方法
3.父类中私有的或者公有的属性和方法, 最后都会变成子类公有的属性和方法

    //父类function Parent(x) {this.x = x}Parent.prototype.getX = function () {console.log(this.x);}//子类function Son(y) {this.y = y}Son.prototype = new Parent(100);//{x:100} ==> __proto__.getX =fnSon.prototype.constructor = B;Son.prototype.getY = function () {console.log(this.y);}let b = new Son(200);b.x //==> undefinedb.getX(); //==> b.getX is not a functionconsole.log(a);//{x:100} ==> __proto__.getX =fnconsole.log(b);//{y:200} ==> __proto__.getY =fn

2call继承

在子类构造函数中把父类构造函数当作普通的函数执行, 并且通过call方法把父类构造函数中的this替换成子类的实例(this), 这样相当于给子类实例设置了私有的属性和方法

特点:
1.只能继承父类私有的属性和方法(因为只是把父类构造函数当作普通函数执行了一次,跟父类的原型上的方法和属性没有任何关系)
2.父类的私有的属性和方法都会变成子类私有的属性和方法

//父类function A(x) {this.x = x;this.seyHello = function (){console.log("hello world");}}A.prototype.getX = function () {console.log(this.x);}let a = new A(100);// A(100);//this => window//子类function B(y,x) {this.y = y; //this ==> b// A(100);//this => windowA.call(this, x);//this => b// this.x = x}B.prototype.getY = function () {console.log(this.y);}let b = new B(200, 100);console.log(b)

3组合继承

结合原型链继承和借用构造函数继承组合起来实现的继承
特点:
(call继承)
1.子类实例可以使用父类私有的属性和方法
2.父类私有的属性和方法都会变成子类实例私有的属性和方法(原型链继承)
3.子类实例可以通过原型链访问和使用父类公有的属性和方法
4.子类的原型链上会存在一份多余的父类的私有属性和方法

//父类function A(x) {this.x = x;this.seyHello = function () {console.log("hello world");}}A.prototype.getX = function () {console.log(this.x);}//子类function B(y, x) {this.y = y;A.call(this, x);}B.prototype = new A();B.prototype.constructor = B;B.prototype.getY = function () {console.log(this.y);}let b = new B(200, 100);console.log(b);

4寄生组合继承

结合原型链继承和call继承的方法,同时自己创建一个对象,并且让这个对象的原型指向父类构造函数的prototype.实现寄生组合继承
特点:
1.最完美的js继承解决方案
2.父类私有的属性和方法,成为子类实例私有的属性和方法
3.父类公有的属性和方法,成为子类实例公有的属性和方法

  //父类function A(x) {this.x = x;this.seyHello = function () {console.log("hello world");}}A.prototype.getX = function () {console.log(this.x);}//子类function B(y, x) {this.y = y;A.call(this, x);}/* let obj = {};obj.__proto__ = A.prototype//因为IE浏览器不支持用户在js中直接使用或者修改__proto__B.prototype = obj*/B.prototype = Object.create(A.prototype);B.prototype.constructor = B;B.prototype.getY = function () {console.log(this.y);}let b = new B(200, 100);console.log(b);// Object.create(arg) 创建空的对象,并且让这个空对象的__proto__指向传递的第一个参数Object.create = function (arg){//因为IE浏览器不支持用户在js中直接使用或者修改__proto__/*let obj = {};obj.__proto__ = arg;return obj*/function NewObj(){}NewObj.prototype = arg;return new NewObj()}

5 ES6中的Class类和继承

ES6 class继承
通过extends来实现继承
class 子类 extends 父类
在constructor中要使用super()
特点
1.父类私有的属性和方法会变成子类私有的属性和方法
2.父类公有属性和方法会变成子类公有的属性和方法

class B extends A{// 通过extends 实现原型链继承constructor(y) {// Must call super constructor in derived classbefore accessing 'this' or returning from derived constructorsuper(100); // call继承(借用构造函数继承)this.y = y;}getY = function () {console.log(this.y);}
}

 class B extends A{// 通过extends 实现原型链继承//如果不写constructor,不会报错 继承会正常实现//如果不写constructor, 浏览器会自动的帮我们去创建一些代码// constructor(...arg){//     super(...arg)// }/*constructor(y) {// Must call super constructor in derived class before accessing 'this' or returning from derived constructorsuper(100); // call继承(借用构造函数继承)this.y = y;}*/getY = function () {console.log(this.y);}}let b = new B(200);console.log(b)