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;//30

//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;//40

//继承的最有效方式