js中的继承

JS 继承实现⽅式也很多，主要分 ES5 和 ES6 继承的实现

ES5实现继承主要是基于prototype来实现的，具体有三种⽅法

⼀，原型链继承：

原型链继承： 子类继承父类的属性和方法

目的： 可以让子类的 实例 能够使用父类的属性和方法

    //父类
    function A(x) {
        this.x = x
    }
    A.prototype.getX = function () {
        console.log(this.x);
    }

    //子类
    function B(y) {
        this.y = y
    }
    B.prototype = new A(100);//{x:100} ==> __proto__.getX =fn
    B.prototype.constructor = B;
    B.prototype.getY = function () {
        console.log(this.y);
    }

    let b = new B(200);
    b.x //==> undefined
    b.getX(); //==> b.getX is not a function

    console.log(a);//{x:100} ==> __proto__.getX =fn
    console.log(b);//{y:200} ==> __proto__.getY =fn

特点:

1.js继承是把父类的原型放到子类的原型链上,实例想要调用这些方法,其实是基于__proto__原型链的机制查找完成的

2.子类可以重写父类上的属性和方法

3.父类中私有的或者公有的属性和方法, 最后都会变成子类公有的属性和方法

⼆，借⽤构造函数继承(call继承) 

all继承(借用构造函数继承)

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

    //父类
    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 => window
        A.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)

    // b = {y:200, x:100}

 特点:

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

2.父类的私有的属性和方法 都会变成子类私有的属性和方法

三，组合继承

组合继承是结合原型链继承 和借⽤构造函数继承⽅式

    //父类
    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);

 特点:

call继承

1.子类实例可以使用父类私有的属性和方法

2.父类私有的属性和方法都会变成子类实例私有的属性和方法

原型链继承

3.子类实例可以通过原型链访问和使用父类公有的属性和方法

4.子类的原型链上会存在一份多余的父类的私有属性和方法

 四，寄生组合继承

寄生组合继承:

结合原型链继承和call继承的方法,同时自己创建一个对象,并且让这个对象的原型指向父类构造函数的prototype.实现寄生组合继承

 

 

    //父类
    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()
    }

特点:

1.最完美的js继承解决方案

2.父类私有的属性和方法,成为子类实例私有的属性和方法

3.父类公有的属性和方法,成为子类实例公有的属性和方法

 ES6继承

ES6 继承是⽬前⽐较新，并且主流的继承⽅式，⽤ class 定义类，⽤ extends 继承类，⽤

super () 表示⽗类

class Parent {
    constructor(value) {
        this.val = value
    }
    getValue() {
        console.log(this.val)
    }
}
class Child extends Parent {
    constructor(value) {
        super(value)
        this.val = value
    }
}
let child = new Child(2)
child.getValue()//2
console.log(child instanceof Parent)//true

特点

1.父类私有的属性和方法 会变成子类私有的属性和方法

2.父类公有属性和方法 会变成子类公有的属性和方法