实现继承的方式（包括类的继承）总结

看了网上好多文章，自己学习了一些，总结如下：

首先我们先定义父类的构造函数：

        //定义父类构造函数
        function Father(name) {
            this.name = name || '父亲'
            this.sayHey = function() {
                console.log(this.name+ '说你好')
            }
        }
        //父类原型对象挂载方法
        Father.prototype.sayGoodbye = function(who) {
            console.log(this.name + '和' + who + '说再见')
        }

一、原型继承

核心：将父类的实例作为子类的原型，使得子类的实例对象可以访问

        // 核心： 将父类的实例作为子类的原型
        function Son() {}
        // 将父级的实例挂载到子级的原型对象上
        Son.prototype = new Father()
        Son.prototype.name = '小李子'

        //验证
        // 子集的实例化对象son
        var son = new Son()
        console.log(son)
        
        console.dir(son)
        son.sayGoodbye('小桂子')
        son.sayHey()
        console.log(son.name)
        console.log(son instanceof Father)   // true
        console.log(son instanceof Son)      // true

优点：

• 非纯粹的继承关系，实例是子类的实例，也是父类的实例
• 父类新增原型方法/原型属性，子类都能访问的到
• 简单

缺点

• 要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中
• 无法实现继承多个
• 来自原型对象的所有属性被所有实例共享
• 创建子类实例时，无法向父类构造函数传参

二、借用构造函数

核心：在子构造函数内部调用父构造函数，利用call()方法执行获得父构造函数的实例方法和属性

        function Son(name) {
            Father.call(this)
            this.name = name || '儿子'
        }
        var son = new Son()
        console.log(son.name)     //儿子
        // son.sayGoodbye('爹')     //报错，该方法在父级的原型上没有继承
        son.sayHey()              //儿子说你好
        console.log(son instanceof Father)   // false
        console.log(son instanceof Son)      // true

特点：

• 创建子类实例时，可以向父类传递参数
• 可以实现多继承（call多个父类对象）

缺点：

• 实例并不是父类的实例，只是子类的实例
• 只能继承父类的实例属性和方法，不能继承原型属性/方法
• 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

三、实例继承

核心：为父类实例添加新特性，作为子类实例返回

        function Son() {
            var sun = new Father()
            sun.name = name || '儿子'
            return sun
        }
        var son = new Son()
        console.log(son.name)
        son.sayHey()
        son.sayGoodbye('父亲')
        console.log(son instanceof Father)    // true
        console.log(son instanceof Son)       // false

特点：

• 不限制调用方式，不管是new子类()还是子类()，返回的对象都具有相同的效果

缺点：

• 实例是父类的实例，不是子类的实例
• 不支持多继承

四、拷贝继承

核心：通过for循环复制方法和属性到原型对象上

        function Son(name) {
            var sun = new Father()
            for (let i in sun) {
                Son.prototype[i] = sun[i]
            }
            Son.prototype.name = name || '儿子'
        }
        var son = new Son()
        console.log(son.name)
        son.sayGoodbye('父亲')
        son.sayHey()

五、组合继承

核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

        function Son(name) {
            Father.call(this)
            this.name = name || '儿子'
        }
        Son.prototype = new Father()
        Son.prototype.constructor = Son
        var son = new Son()
        son.sayHey()
        son.sayGoodbye('父亲')
        console.log(son.name)
        console.log(son instanceof Son)     //true
        console.log(son instanceof Father)  //true

特点：

• 弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
• 既是子类的实例，也是父类的实例
• 不存在引用属性共享问题 函数可复用
• 可传参

缺点：

• 调用了俩次构造函数，生成了俩份实例（子类实例将子类原型上的那份屏蔽了）

六、寄生组合继承

核心：通过寄生方式，砍掉父类的实例属性，这样，在调用俩次父类的构造的时候，就不会初始化俩次实例方法/属性，避免了组合继承的缺点。

        function Son(name) {
            Father.call(this)
            this.name = name || '儿子'
        }
        (function () {
            // 创造一个没有实例的方法类
            var Super = function() {}
            Super.prototype = Father.prototype
            // 将实例作为子类的原型
            Son.prototype = new Super()
        }())
        var son = new Son()
        console.log(son.name)
        son.sayGoodbye('父亲')
        son.sayHey()
        console.log(son instanceof Son)
        console.log(son instanceof Father)
        
        Son.prototype.constructor = Son;	//修复构造函数

完美，就是较为复杂

七、类的继承

Class继承，es6新增，其实是一个语法糖—底层是原型链继承方式
通过extends关键字继承。

	class Father {
	     constructor(surname) {
	       this.surname= surname;
	     }
	     say() {
	       console.log('你的姓是' + this.surname);
	      }
	}
	​
	class Son extends Father{  // 这样子类就继承了父类的属性和方法
	}
	var damao= new Son('刘');
	damao.say();      //结果为 你的姓是刘