javascript中的继承

继承有什么好处？很简单，继承了你爸的财产，本身就能够少奋斗点嘛。开玩笑，言归正传，继承使子类拥有超类的做用域、属性与方法，能够节省程序设计的时间。ECMAScript实现继承主要方式是依靠原型链。

原型链方式——不建议使用

function SuperType(){
    this.colors = ["red", "blue", "green"];
}
function SubType(){
}
//利用原型链继承
SubType.prototype = new SuperType();
var instance1 = new SubType();
console.log(instance1.colors) //["red", "blue", "green"]

上例中，经过SubType.prototype = new SuperType()使SubType的原型链上增长了SuperType()这一环。从而使SubType 经过原型链继承了SuperType的color属性。

存在的问题：

1. 实例共享
   在上面的例子中加入如下代码，发现SubType()的实例1对color属性作出改变后，实例2获取到的color属性是改变后的值。这是由于：

   每一个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针。

instance1.colors.push("black");
console.log(instance1.colors); //["red", "blue", "green", "black", "black"]
var instance2 = new SubType();
console.log(instance2.colors);//["red", "blue", "green", "black", "black"]

• 首先，instance1和instance2都是SubType()的实例，这俩个实例都会包含一个指向原型对象的内部指针
• SubType()的原型指向SuperType()的一个实例，并且这个实例指向的是SuperType()的原型对象
• SuperType()的原型对象又指向SuperType()。最终，instance1.colors和instance2.colors的指向都是SuperType()的colors。

1. 没有办法在不影响全部对象实例的状况下，给超类型的构造函数传递参数，原理同上。

构造函数方式——不建议使用

function SuperType(){
    this.colors = ["red", "blue", "green"];
}
function SubType(){
    //继承了SuperType
    SuperType.call(this);
}
var instance1 = new SubType();
console.log(instance1.color)//["red", "blue", "green"]

基本思想即在子类型构造函数的内部调用超类型构造函数。

call和apply
全局函数apply和call能够用来改变函数中this的指向。

存在的问题：

1. 子类型没法继承超类原型链，致使全部类型都只能使用构造函数模式；
2. 方法都在构造函数中定义，函数没法复用。

组合继承——最经常使用的继承模式

function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
    console.log(this.name);
};
function SubType(name, age){
    //继承属性
    SuperType.call(this, name);   //第二次调用SuperType()
    this.age = age;
}
//继承方法
SubType.prototype = new SuperType(); //第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    console.log(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
console.log(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";
instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
console.log(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge();

基本思想：

• 经过原型链来继承超类的sayName()方法；
• 经过构造函数的方式来使SuperType()里的属性私有化；

为何能够实现属性私有化？

• 第一次调用超类，SubType.prototype 会获得两个属性：name 和colors；它们都是SuperType 的实例属性，位于SubType 的原型中；
• 第二次调用超类，在新对象上建立了实例属性name 和colors。因而，这两个属性就屏蔽了原型中的两个同名属性；

存在的问题：
不管什么状况下，都会调用两次超类型构造函数:：一次是在建立子类型原型的时候，另外一次是在子类型构造函数内部

原型式继承

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");
var yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.friends.push("Barbie");
console.log(person.friends); //["Shelby", "Court", "Van", "Rob", "Barbie"]

ECMAScript 5 经过新增Object.create()方法规范化了原型式继承。这个方法接收两个参数：一个用做新对象原型的对象和（可选的）一个为新对象定义额外属性的对象

• 将person对象做为基础对象
• 把person对象传入到object()函数中，而后该函数就会返回一个新对象F()，这个新对象将person 做为原型
• 适用于让一个对象与另外一个对象保持相似的状况

存在同原型链方式同样的问题

寄生式基础

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}
function createAnother(original){
    var clone = object(original); //经过调用函数建立一个新对象
    clone.sayHi = function(){ //以某种方式来加强这个对象
    console.log("hi");
};
return clone; //返回这个对象
}
var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = createAnother(person);
anotherPerson.sayHi(); //"hi"

• 将person对象做为基础对象
• 将基础对象传递给object()函数，将返回的新对象赋值给clone；（示范继承模式时使用的object()函数不是必需的；任何可以返回新对象的函数都适用于此模式。）
• 为clone 对象添加一个新方法sayHi()，最后返回clone 对象

寄生组合式继承——被认为是引用类型最理想的继承范式

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}
function inheritPrototype(subType, superType){
    var prototype = object(superType.prototype); //建立对象
    prototype.constructor = subType; //加强对象
    subType.prototype = prototype; //指定对象
}

function SuperType(name){
    this.name = name;
    this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
    console.log(this.name);
};
function SubType(name, age){
    SuperType.call(this, name); //调用一次SuperType()
    this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
    console.log(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.sayName();
console.log(instance1.colors);

• 将超类的原型对位基础对象，而且传递给object()函数，返回新对象赋值给prototype；
• 将子类的原型指向prototype，即超类的原型，这里继承了超类的sayName方法
• 子类中利用构造方法使子类上建立了name和colors属性

参考书籍：《javascript高级程序设计》

个人博客:http://bigdots.github.io、http://www.cnblogs.com/yzg1/

若是以为本文不错的话，帮忙点击下面的推荐哦,谢谢！