js实现继承的几种方式

首先重要的一点

例子里关于Person和Student的设计，不符合面向对象的设计原则，我后面重新看自己写的文章才发现，有空的话我会把这些重新改掉。但是不影响理解核心内容

延续原型和原型链的学习，记录下继承！

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

		    function Person(skinColor = 'yellow', gender = 1) {
                this.skinColor = skinColor;
                this.gender = gender;
                this.eat = function () {
                    console.log('eating!');
                }

            }
            function Student(name = 'bob', ability = ['code', 'dance']) {
                this.name = name;
                this.ability = ability;
            }
            Student.prototype = new Person();
            Student.prototype.constructor = Student;
            var bob = new Student();

构造函数继承

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

			function Person(skinColor = 'yellow', gender = 1) {
                this.skinColor = skinColor;
                this.gender = gender;
                this.eat = function () {
                    console.log('eating!');
                }
            }
            function Student(name = 'bob', ability = ['code', 'dance']) {
                this.name = name;
                this.ability = ability;
                Person.call(this);
            }
            var bob = new Student();

组合继承（组合原型链和构造函数继承）
重点：组合了原型链继承和构造函数继承
特点：保留了构造函数继承与原型链继承的优点，是比较常用的继承方式
缺点：执行了两次Person，属性重复了。

            function Person(skinColor = 'yellow', gender = 1) {
                this.skinColor = skinColor;
                this.gender = gender;
                this.eat = function () {
                    console.log('eating!');
                }

            }
            function Student(name = 'bob', ability = ['code', 'dance']) {
                this.name = name;
                this.ability = ability;
                Person.call(this);
            }
            Student.prototype = new Person();
            Student.prototype.constructor = Student;
            var bob = new Student();
          

寄生组合继承

重点：定义一个新的变量，把父类的原型对象间接的给子类，避免了new一个父类实例的操作
特点：比较完美的继承方案，优化了组合继承中调用两次Person实例的操作

            function Person(skinColor = 'yellow', gender = 1) {
                this.skinColor = skinColor;
                this.gender = gender;
                this.eat = function () {
                    console.log('eating!');
                }

            }
            function Student(name = 'bob', ability = ['code', 'dance']) {
                this.name = name;
                this.ability = ability;
                Person.call(this);
            }
            var prototype = Object.create(Person.prototype);
            prototype.constructor = Student;
            Student.prototype = prototype;
            var bob = new Student();

在es6中对继承有了更友好的方式：extends

对于extends的解释，需要先了解es6的class。es6真的是js面向对象的一个重大版本！

           // 使用匿名类的方式创建
		   let Person = class {
                constructor(skinColor = 'yellow', gender = 1) {
                    this.skinColor = skinColor;
                    this.gender = gender;
                }
                eat() {
                    console.log('eating!');
                }
            }
            let Student = class extends Person {
                constructor(name = 'bob', ability = ['code', 'dance']) {
                   // super关键字用于访问和调用一个对象的父对象上的函数
                    super();
                    this.name = name;
                    this.ability = ability;
                }
            }
            let bob = new Student();