2. 继承
继承是OO语言中最为人津津乐道的概念。许多支持OO的语言都支持两种方式的继承：接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法实现。由于ECMAScript中没有函数签名的概念，因此无法实现接口继承。而实现继承在ECMAScript中，则是依靠原型链来实现的。
2.1 原型链
使用原型链实现继承的基本思想是：将子类型的prototype指向一个父类型的实例，因此字类型通过原型查找就获得了父类型的属性和方法。而父类型的实例本身又包含了一个指向父类型原型的指针，这就串成了一条原型链。下面是一个例子：
function SuperType(){
this.property = true;
}
SuperType.prototype.getSuperValue = function(){
return this.property;
}
function SubType(){
this.subProperty = false;
}
SubType.prototype = new SuperType(); //SubType继承SuperType
SubType.prototype.getSubValue(){
return this.subProperty;
}
var instance = new SubType();
alert(instance.getSuperValue()); //true
以上代码定义了两个类型：SuperType和SubType。SubType通过重写它的原型对象为父类型实例，从而实现了继承父类型的属性和方法。然后又在原型中添加了getSubValue()方法。下图清晰的表明了继承后的构造函数，原型以及实例之间的关系：
通过原型链，本质上扩展了本章前面介绍的原型搜索机制。当以读取模式访问一个实例属性时，会经历以下三个步骤：
（1）搜索当前实例对象
（2）搜索SubType.prototype，这儿实际上时SuperType的一个实例
（3）搜索SuperType.prototype
事实上，前面的例子展示的原型链还缺少一环。我们知道，所有的引用类型都默认继承了Object，而这个继承也是通过原型链实现的。所有函数的默认原型都是一个Object引用类型的实例，因此默认原型都包含一个内部指针（[[Prototype]]），指向Object.prototype。这也正是所有自定义类型都会继承toString()，valueOf()方法的根本原因。下图是一个完整的原型链的例子：
还有一点需要注意，在通过原型链实现继承时，不能使用对象字面量的方式创建原型对象。因为这样就会重写原型链。下面是一个例子：
function SuperType(){
this.property = true;
}
SuperType.prototype.getSuperValue = function(){
return this.property;
}
function SubType(){
this.subProperty = false;
}
SubType.prototype = new SuperType(); //SubType继承SuperType
//重写了SubType.prototype，从而不再指向父类型实例
SubType.prototype = {
getSubValue: functiion(){
return this.subProperty;
}
}
var instance = new SubType();
alert(instance.getSuperValue()); //error
2.2 借用构造函数
原型链模式虽然强大，然而存在一个问题：那就是包含引用类型的原型属性会被所有实例对象共享。这也是为什么需要在构造函数中而不是原型对象中定义属性。然而通过原型链实现继承，将字类型原型指向了父类型实例，因此如果父类型包含引用类型的属性，那么这个属性就会被所有字类型实例共享。这就会造成问题。下面是一个例子：
function SuperType(){
this.colors = ["red", "black"];
}
function SubType(){
}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push("blue");
alert(instance1.colors); //"red,black,blue"
var instance2 = new SubType();
alert(instance2.colors); //"red,black,blue"
为了解决原型中包含引用类型值所带来的问题，可以使用一种名为借用构造函数（constructor stealing）的技术。这种技术很简单，即在子类型构造函数内部通过调用超类型的构造函数。由于函数只不过时在特定执行环境中执行代码的对象，因此我们可以使用apply或call方法在新对象上调用超类型构造函数，从而使新对象拥有自己独立的属性或方法。下面是一个例子：
function SuperType(){
this.colors = ["red", "black"];
}
function SubType(){
SuperType.call(this);
}
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push("blue");
alert(instance1.colors); //"red,black,blue"
var instance2 = new SubType();
alert(instance2.colors); //"red,black"
在上面的例子中，我们通过在子类型构造函数中执行SuperType.call(this);使得SuperType()函数在SubType实例环境下运行，因此该SubType实例就拥有了独属于自己的colors属性。
另外，借用构造函数还有一个很大的优势，那就是可以通过子类型构造函数向父类型构造函数传递参数。下面是一个例子：
function SuperType(name){
this.name = name;
}
function SubType(){
SuperType.call(this, "Ivan");
this.age = 22;
}
var instance = new SubType();
alert(instance.name); //"Ivan"
alert(instance.age); //22
如果仅仅是借用构造函数，那么也将无法避免构造函数模式存在的问题——方法都在构造函数中定 义，因此函数复用就无从谈起了。
2.3 组合继承
组合继承（combination inheritance）有时候也叫做伪经典继承。指的是将原型链技术和借用构造函数技术组合在一起，从而实现继承。下面是一个例子：
function SuperType(name){
this.name = name;
this.colors = ["red", "blue", "green"];
}
SuperType.prototype.sayName = function(){
alert(this.name);
};
function SubType(name, age){
//继承属性
SuperType.call(this, name);
this.age = age;
}
//继承方法
SubType.prototype = new SuperType();
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
alert(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";
instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
alert(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge(); //27
组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为JavaScript中常用的继承模式。而且，instanceof 和 isPrototypeOf()也能够用于识别基于组合继承创建的对象。
2.5 寄生组合式继承
前面说过，组合继承是 JavaScript 常用的继承模式；不过，它也有自己的不足。组合继承大的 问题就是无论什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候（new SuperType()），另一次是 在子类型构造函数内部（ SuperType.call()）。没错，子类型终会包含超类型对象的全部实例属性，但我们不得不在调用子 类型构造函数时重写这些属性，这就意味着超类型的属性会有两组：一组在字类型对象实例中，另一组在子类型原型对象中。
而所谓寄生组合式继承，认为字类型原型对象中的属性是一种浪费。不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。因此下面是一个寄生组合式继承的例子：
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(){
alert(this.name);
};
function SubType(name, age){
//继承属性
SuperType.call(this, name);
this.age = age;
}
inheritPrototype(SubType, SuperType);
SubType.prototype.sayAge = function(){
alert(this.age);
};
var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";
instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
alert(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge(); //27
这个例子的高效率体现在它只调用了一次 SuperType 构造函数，并且因此避免了在 SubType. prototype 上面创建不必要的、多余的属性。与此同时，原型链还能保持不变；因此，还能够正常使用 instanceof 和 isPrototypeOf()。开发人员普遍认为寄生组合式继承是引用类型理想的继承范式。
