javascript实现继承3种方式： 原型继承、借用构造函数继承、组合继承，模拟extends方法继承

javascript中实现继承的三种方式：原型继承、借用构造函数继承、混合继承：

 /*
     js当中的继承
 
     js中 构造函数 原型对象 实力对象的关系：
         1 构造函数.prototype = 原型对象
         2 原型对象.constructor = 构造函数（模板）
         3 原型对象.isPrototypeOf(实例对象)  判断实例对象的原型是不是当前对象
         4 构造函数 实力对象 是 类和对象的关系
 */
 
 /*
 1 原型继承
         给子类构造函数的原型对象赋值为父类构造函数的实例
     赋值之后产生的关系：
         1 子类的原型对象是父类的一个实例   Son.prototype 是 new Father()
         2 父类的方法和属性，子类可以在原型中得到
         3 子类的原型对象的构造器是父类模板    Son.prototype.constructor 是 Father
         4 子类的原型对象的原型对象是父类的原型对象    Son.prototype.prototype 是Father.prototype
     原型继承的特点：
         子类继承了父类所有属性方法发和 父类原型对象中的属性和方法
     缺点： 不能在子类实例化对象的时候给父类的属性赋值，继承父类的值和子类对象实例化分开了。
 */
 
 //父类构造函数
 function Father(name){
     this.name = name;
 }
 //父类原型对象
 Father.prototype={
     constructor: Father,
     id:10,
     sayName:function(){
         alert(this.name);
     }
 };
 
 //子类构造函数
 function Son(age){
     this.age = age;
 }
 //子类原型对象 这一家子都姓张
 Son.prototype = new Father("张");
 
 //子类的实例 能够使用父类的属性和方法
 var s1 = new Son(18);
 //s1.sayName();    //张
 //alert(s1.age);    //18        
 
 /*
     原型继承的特点：
         子类继承了父类所有属性方法发和 父类原型对象中的属性和方法
     缺点： 不能在子类实例化对象的时候给父类的属性赋值，继承父类的值和子类对象实例化分开了。
 */
 
 /*
 2 类继承（借用构造函数） 只继承父类的构造函数，父类的原型对象没有继承过来
     利用call 或者apply进行函数绑定，借用父类构造函数的属性和方法
 */
 //父类构造函数
 function Father(name){
     this.name = name;
 }
 //父类原型对象    在子类中不能继承父类原型对象中的内容
 Father.prototype.id = 10;
 
 //子类构造函数
 function Son(name,age){
     //name属性是父类的 不是子类的 借用父类的构造函数 把属性绑定给子类的实例对象
     Father.call(this,name);
     this.age = age;
 }
 //实例化子类对象 在这里可以直接给继承来的属性赋值
 var s2 = new Son("z3",18);
 //alert(s2.name);    //z3  父类构造函数绑定来的属性
 //alert(s2.age);    //18  子类自己的属性
 
 /*
     类继承（借用构造函数） 的特点：
         优点： 能够在实例化子类对象时候给继承父类的属性赋值
         缺点：父类的原型对象中的内容无法继承
 */
 
 /*
 3 混合继承：原型继承 和 借用构造函数继承 的混合
     特点：
         优点：1 能够在实例化子类对象的时候给继承来的属性赋值
                2 能够继承父类的原型对象中的方法
         缺点： 继承了两次父类的模版，分别是call绑定和子类原型对象赋值的时候
                 如果继承来的属性特别多，这会很耗费时间来维护
 */
 //父类
 function Father(name){
     this.name = name;
 }
 //父类的原型对象
 Father.prototype = {
     constructor:Father,
     id:10,
     sayName:function(){
         alert(this.name);
     }
 };
 //子类
 function Son(name,age){
     //借用父类构造函数 绑定子类方法 为子类继承来的属性赋值
     Father.call(this,name);
     this.age = age;
 }
 //原型继承 不传递参数，继承自父类的属性赋值交给借用父类构造函数去做
 Son.prototype = new Father();
 
 //使用子类实例化对象
 var s3 = new Son("l4",20);
 //alert(s3.name);    //父类属性
 //alert(s3.id);    //父类原型对象的属性
 //alert(s3.age);    //自己的属性
 //s3.sayName();    //父类原型对象中的方法
 /*
     混合集成的特点：
         优点：1 能够在实例化子类对象的时候给继承来的属性赋值
                2 能够继承父类的原型对象中的方法
         缺点： 继承了两次父类的模版，分别是call绑定和子类原型对象赋值的时候
                 如果继承来的属性特别多，这会很耗费时间来维护
 */

但是 上面三种方式 即使是混合继承也有弊端，下面用js模拟一下extends的继承方，来实现不会重复继承父类的构造函数：

 /*
 javascript模拟extends方法，
     目的：
         1子类实例化能够赋值继承来的属性
         2 继承父类的原型对象
         3 父类的构造函数只继承一次
 */
 
 //1 我们模拟一个extends函数 用于实现类之间的继承 传入父类和子类
 function extend(son,father){
     //让子类继承父类的原型而不继承父类构造函数的内容
     var f = new Function(); //临时空函数，目的是函数内部是空的 但是原型是父类的原型
     f.prototype = father.prototype;    //让空函数的原型指向父类的原型
     son.prototype = new f();    //让子类的原型指向一个空函数，空函数的原型是父类的原型，这就避免了父类构造函数的属性被重复实现
     //给子类添加一个superClass属性保存父类的原型对象，防止自己重写了父类方法后 无法调用父类原型对象中的方法
     son.superClass = father.prototype;
     //为父类原型对象添加构造器  如果父类原型对象忘记加构造器这里给他加上
     if(father.prototype.constructor == Object.prototype.constructor){
         father.prototype.constructor = father;
     }
 }
 //2 父类
 function Father(name){
     this.name = name;
 }
 //父类的原型对象
 Father.prototype = {
     constructor: Father,
     sayName:function(){
         alert(this.name);
     }
 };
 
 //3 子类
 function Son(name,age){
     //借用构造函数：为子类绑定父类的构造函数中属性
     // Father.call(this , name); 这里不这样写，为了解耦，增加通用性，经过extentds函数之后，子类里面有了父类的属性
     Son.superClass.constructor.call(this , name);    //Son.superClass是父类的原型对象，consturctor就是父类构造函数
     this.age = age;
 }
 //原型继承
 //Son.prototype = new Father(); //会再次绑定一次父类的构造函数 ，这里为了不重复继承父类构造函数，只继承父类原型对象 我们用自己
 //调用自己的继承方法 实现为子类继承父类的原型对象 而不继承父类的构造函数
 
 extend(Son,Father);
 
 //使用子类
 var s4 = new Son("haha",33);
 alert(s4.name);    //haha 父类继承来的属性
 alert(s4.age);    //33 自己的属性
 s4.sayName();    //haha  父类继承来的方法
 //重写父类方法
 s4.sayName = function(){
     alert("hello i am son");
 };
 s4.sayName();    //hello i am son 重写方法覆盖了父类的sayName
 //重写之后还想调用父类的方法    需要绑定一下 指定是我这个对象来调用
 Son.superClass.sayName.call(s4);    //haha