JS中对象的继承

原型继承

        function Person() {
            this.name = '张三';
            this.arm = ['左', '右']
            this.say = function () {
                console.log(this.name + '挺能说')
            }
        }


        function Student() {

        }
        Student.prototype = new Person();


        var stu = new Student()
        stu.arm.push('中')
        console.log(stu.arm)
        var stu1 = new Student();
        console.log(stu1.arm)

     把子类的原型指向父类的实例，

        缺点：使用子类 new 出来的实例__proto__指向的是父类构造函数,和子类没有什么直接的关系，

        子类不能向父类传递参数

        当父类的属性是引用类型的时候，子类的实例对象修改后，会影响所有的子类实例

借用构造函数继承

// 借用构造函数继承（经典继承）
        function Person(){
            this.name = 'xiaopao';
            this.colors = ['red', 'blue', 'green'];
        }

        Person.prototype.getName = function(){
            console.log(this.name);
        }

        function Child(){
            Person.call(this);
        }

        var child1 = new Child();
        var child2 = new Child();
        child1.colors.push('yellow');
        console.log(child1.name);
        console.log(child1.colors); // ["red", "blue", "green", "yellow"]
        console.log(child2.colors); // ["red", "blue", "green"]

不可以使用父类中原型的方法或者属性

组合继承

组合 原型链继承 和 借用构造函数继承
背后的思路是：使用原型链实现对原型方法的继承，而通过借用构造函数来实现对实例属性的继承。

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

        Parent.prototype.getName = function () {
            console.log(this.name);
        }

        function Child() {
            //改变父类的指向
            Parent.call(this);
        }
       // Child.prototype = Object.create(Parent.prototype) //子类和父类指向不同的地址，子类添加原型不会影响父类
        Child.prototype = Parent.prototype   //子类和父类指向同一地址，互相影响
        Child.prototype.constructor = Child;
        Child.prototype.say = function () {
            console.log('子类方法')
        }


        var child1 = new Child();
        var child2 = new Child();


        var parent1 = new Parent()
        parent1.say()

寄生继承

        function extend(obj) {
            var F = function () { }
            F.prototype = obj;
            return new F();
        }


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

        Parent.prototype.getName = function () {
            console.log(this.name);
        }

        function Child() {
            //改变父类的指向
            Parent.call(this);
        }


        Child.prototype = extend(Parent)
        Child.prototype.say = function () {
            console.log(this.colors)
        }

        var child1 = new Child();
        var child2 = new Child();
        console.log(child1.__proto__)

缺点：比较麻烦，每次子类实例的对象的构造函数指向的是F（）和实际的子类Child没多大关系。

寄生组合继承

        function extend(subs, parent) {
            subs.prototype = Object.create(parent)
            subs.prototype.constructor = subs
        }


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

        Parent.prototype.getName = function () {
            console.log(this.name);
        }

        function Child() {
            //改变父类的指向
            Parent.call(this);
        }


        extend(Child, Parent)
        Child.prototype.say = function () {
            console.log(this.colors)
        }

        var child1 = new Child();
        var child2 = new Child();
        console.log(child1.__proto__)