js继承

 

构造函数的原型继承

        function qq(name,age) {
            this.name = name
            this.age = age
        }
        qq.prototype.eat = function () {
            console.log(this.name + '吃饭了')
        } 
        var f1 = new qq('熊熊',19)
        function son(){

        }
        son.prototype = f1
        var aa = new son()
        aa.eat()

注意：

当 son.prototype 指向 f1 时，它就已经是当爸爸的son了；

aa.eat() ; aa 中没有这此方法，该方法在父亲son原型中，当aa访问时，先在aa本身下查找，若没有则向它指向的原型中去查找该方法，若还是没有，则继续往上面的原型找。这样就形成了一条原型链。

 

通过原型链继承。

简写：

var f1 = new qq

var son.prototype = f1

// 直接简写成：

var son.prototype = new qq()

 

原型式继承

这种继承借助原型并基于已有的对象创建新对象，
同时还不必因此创建自定义类型 

function obj(o) {
            function F() {}
            F.prototype = o;
            return new F();
        }
        var box = {
            name:'熊熊',
            arr:["哥哥","妹妹","姐姐"]
        }
        var box1 = obj(box);
        console.log(box1.name)
        box1.name = '露露'
        console.log(box1.name)
        console.log(box1.arr)
        box1.arr.push('父母')
        console.log(box1.arr)
        var box2 = obj(box);
        console.log(box2.name)
        console.log(box2.arr) //引用类型共享了

 

 

组合继承

// 组合继承的优点在于属性和方法都可以继承
        // 组合继承 = 原型继承 + 构造函数继承
        function Supertype(name){
            this.name = name
            this.colors = ["red","orange","yellow"]
        }
        Supertype.prototype.Sayname = function(){
            console.log(this.name)
        }
        function Subtype(name,age){
            Supertype.call(this,name);
            this.age = age;
        }
        Subtype.prototype = new Supertype();
        Subtype.prototype.constructor = Subtype;
        Subtype.prototype.sayage = function(){
            console.log(this.age)
        }
        var instance = new Subtype("熊熊",19);
        instance.colors.push("green")
        console.log(instance.colors)
        instance.Sayname()
        instance.sayage()

 

寄生组合继承   

未完待续。。