JavaScript 继承的几种模式

 /**
  * Created by 2016 on 2016/6/5.
  */
 //1、原型链继承
 //把子类的原型，定义为超类的实例  通过原型来访问超类的方法和属性
 function Person(){//超类
     this.age = 40;
     this.run = function(){
         console.log("Person is running");
     }
 }
 function Student(){}//子类
 Student.prototype = new Person();//实现继承

 //注意：如果要重写或者添加子类的方法，需要在继承之后。
 //缺点：1、如果属性中存在引用类型的值，由于属性是共享的，修改属性会同步修改。
 //      2、无法给超类的构造函数传递参数
 //      3、无法实现多继承

 //2、借用构造函数
 //在子类的构造函数内部调用超类的构造函数。利用apply（obj，[]）和call（obj,arg1,arg2）函数
 function Person(){//超类
     this.age = 40;
     this.run = function(){
         console.log("Person is running");
     }
 }

 function Student(){
     Person.call(this);//调用超类的构造函数，这里可以传递参数
 }

 var student = new Student();
 student.run();//"Person is running"
 //缺点：1、借用构造函数，导致所有的方法都在构造函数中定义，方法无法复用
 //      2、超类原型中的方法和属性，对于子类来说是无法访问的，导致所有类型都必须使用构造函数模式。

 //3、组合继承
 //伪经典继承 将原型链继承和借用构造函数的继承组合起来使用。借用构造函数方式实现属性的继承，原型链的方式实现方法继承
 //实现了方法的复用和属性的独立。组合继承是常用的继承方式
 function Person(){
     this.age = 40;
 }
 Person.prototype = {
     constructor:Person,
     run:function(){
         console.log("Person is running");
     }
 };
 function Student(){
     Person.call(this);//继承属性
 }
 Student.prototype = new Person();//继承方法

 //缺点：由于属性和方法分开继承，导致一定会调用两次的超类构造函数。可以使用寄生组合继承的方式优化。

 //4、原型式继承
 //基于原型继承，和原型链的继承相似，这里返回一个子类的实例
 function object(o){
     function F(){}//创建一个临时构造函数
     F.prototype = o;
     return new F();
 }
 //ECMAScript5对原型式继承进行了规范，可以使用Object.create（）方法来继承。这个函数接收两个参数，用作子类原型的超类对象，和
 // （可选的）为新对象指定的属性对象，看代码

 var Person = {//超类
     age:40,
     run:function(){
         console.log("Person is running");
     }
 };
 var student = Object.create(Person,{age:30});
 student.run();//Person is running
 student.age;//

 //5、寄生继承
 //使用一个函数来实现继承，函数参数为超类对象，通过复制超类对象——增强对象——返回结果对象的方式，来实现继承

 function createObject(obj){
     var newObj = object(obj);//创建新对象
     newObj.run = function(){//增强对象
         console.log("Person is running");
     };
     return newObj;//返回结果对象
 }
 var Person ={
     age : 40,
     walk : function(){
         console.log("Person is walking");
     }
 };
 var student = createObject(Person);
 student.walk();
 student.run();

 //注意：这里传入的obj必须是实例，不能是构造函数。
 //缺点：和借用构造函数方式一样，方法无法复用。

 //6、寄生组合式继承
 //避免组合式继承调用两次超类的构造函数，提高效率
 function inheritPrototype(subType,superType){//继承原型函数，参数为子类，超类
     var prototype = Object.create(subType.prototype);//生成超类的原型副本
     prototype.constructor = subType;//将原型副本的constructor指向子类
     subType.prototype = prototype;//指定子类的新原型，实现继承属性

 }
 function Person(){
     thi.age = 40;
 }
 Person.prototype = {
     run:function(){
       console.log("Person is walking");
     }
 };
 function Student(){
     Person.call(this);
 }
 inheritPrototype(Student,Person);//继承超类（原型继承）
 var student = new Student();
 student.run();//"Person is walking"
 student.age;//

 //继承的最有效方式