js封装、继承

原型链继承：

        //  父类 
        function Persion(name,age){ 
            this.name = name; 
            this.age = age; 
        }
        // 父类的原型对象属性 
        Persion.prototype.id = 110;
        // 子类 
        function Boy(sex){ 
            this.sex = sex;
        }
        // 继承实现 
        Boy.prototype = new Persion('雷佳',25);
         var b = new Boy(); 
         console.log(b.name)// 雷佳

　　优点：子类不仅仅可以访问父类原型上的属性和方法，同样也可以访问从父类构造函数中复制的属性和方法

　　缺点：1.一个子类原型更改子类原型从父类继承来的引用类型属性就会直接影响其他子类；
　　　　　2.由于子类实现的继承是靠其原型对父类的实例化实现的，因此在创建父类的时候，是无法向父类传递参数的，因而在实例化父类时也无法对父类构造函数的属性进行初始化。

构造继承：

       //  父类 
        function Persion(name,age){ 
            this.name = name; 
            this.age = age; 
        }
        // 父类的原型对象属性 
        Persion.prototype.id = 110;
        // 子类 
        function Boy(name,age,sex){ 
            //call apply 实现继承
            Persion.call(this,name,age);
            this.sex = sex;
        }
         var b = new Boy('雷佳',25,'女'); 
         console.log(b.name)// 雷佳 
         console.log(b.id)//undinfind 父类的原型对象并没有继承

　　优点：避免了引用类型的属性被所有实例共享，而且可以在子类中向父类传参

　　缺点：这种类型的继承没有涉及原型prototype，所以父类的原型方法自然不会被子类继承，而要想被子类继承就必须把放在构造函数里，这样创建出来的每个实例都会单独拥有一份而不能共用，这样就违背了代码复用的原则

混合继承：

基于此，为了综合这两种模式的优点，就有了组合继承。

     //  父类 
        function Persion(name,age){ 
            this.name = name; 
            this.age = age; 
        }
        // 父类的原型对象属性 
        Persion.prototype.id = 110;
        // 子类 
        function Boy(name,age,sex){ 
            //call apply 实现继承
            Persion.call(this,name,age);
            this.sex = sex;
        }
        // 原型继承实现  参数为空 代表 父类的实例和父类的原型对象的关系了
        Boy.prototype = new Persion();
        var b = new Boy('雷佳',25,'女'); 
        console.log(b.name)// 雷佳
        console.log(b.id)//110

首先，在子类构造函数执行了父类构造函数，然后子类原型上实例化父类就是组合模式。如此，组合式继承就融合了原型链继承和构造函数继承的优点，并且过滤了其缺点。