ECMAScript 中无法实现接口继承。ECMAScript支持实习继承，而且实现继承主要是依靠原型链来实现的。
原型链
ECMAScript 中描述了原型链的概念，并将原型链作为实现继承的主要方法。基本思想是利用原型让一个引用类型和另一个引用类型的属性和方法。
构造函数、原型和实例的关系： 每个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实际都包含一个指向原型对象内部指针。 假如我们让原型对象等于另一个类型的实例，此时的原型对象将包含一个指向另一个原型的指针，另一个原型中也包含一个指向另一个构造函数的指针。 假如另一个原型又是一个类型的实例，那么上述关系依然成立，如此层层递进，就构成了实例与原型的链条。
function SuperType() {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
}
function SubType() {
this.subProperty = false;
}
// 继承 了SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function() {
return this.subProperty;
}
var instance = new SubType();
alert(instance.getSuperValue()) // true
上例代码定义了两个类型：SuperType 和 SubType。每个类型分别有一个属性和一个方法。它们的主要区别是 SubType 继承了 SuperType，而继承是通过创建 SuperType 的实例，并将该实例赋给 SubType.prototype 的实例。换句话说，原来存在于 SuperType 的实例中的所有属性和方法现在也存在于 SubType.prototype 中了。在确立了继承关系之后，我们给 SubType.prototype 添加了一个方法，这样就在继承了 SuperType 的属性和方法的基础上又添加了一个新方法。
上例中 SubType 的原型被修改为 SuperType 的实例，而 instance 指向 SubType 的原型，所以 instance 的原型指向 SubType 的原型 SuperType。那么 instance 的 constructor 就指向了 SuperType。
实际上，不是 SubType 的原型的constructor 属性被重写了，而是 SubType 的原型指向了另一个对象 ---- SuperType 的原型，而这个原型对象的 constructor 属性指向的是 subProperty.
默认原型链
所有引用类型默认都继承了 Object 的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。这也正是所有自定义类型都会继承 toString()、valueOf()、等默认方法的根本原因。
确定原型和实例的关系
- 通过 instanceof 操作符，只要用这个操作符来测试实例与原型链中出现过的构造函数，结果就会返回 true。
- 使用 isPrototypeOf() 方法。只要是原型链中出现过的原型，都可以说是该原型链派生的实例的原型。
alert(instance instanceof Object); // true
alert(instance instanceof SubType); // true
alert(instance instanceof SuperType); // true
alert(Object.prototype.isPrototypeOf(instance)); // true
alert(SubType.prototype.isPrototypeOf(instance)); // true
alert(SuperType.prototype.isPrototypeOf(instance)); // true
谨慎地定义方法
子类型有时候需要重写超类型中的某个方法，或者需要添加超类型中不存在的某个方法。但不管怎样，给原型添加方法的代码一定要放在替换原型的语句之后。
function SuperType() {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
}
function SubType() {
this.subProperty = false;
}
// 继承 了SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function() {
return this.subProperty;
}
// 重写超类型中的方法
SubType.prototype.getSuperValue = function() {
return false;
}
var instance = new SubType();
alert(instance.getSuperValue()) // false
alert(new SuperType().getSuperValue()) // true
第一个方法 getSubValue() 被添加到了 SubType 中。 第二个方法 getSuperValue() 是原型链中已经存在的一个方法，但重写这个方法将会屏蔽原来的那个方法。
当通过 SubType 的实例调用 getSuperValue() 时，调用的就是这个重新定义的方法；但通过 SuperType 的实例调用 getSuperValue() 时，还会继续调用原来的那个方法。
注意：通过原型实现继承时，不能使用对象字面量创建原型方法，这样会重写原型链
function SuperType() {
this.property = true;
}
SuperType.prototype.getSuperValue = function() {
return this.property;
}
function SubType() {
this.subProperty = false;
}
// 继承 了SuperType
SubType.prototype = new SuperType();
// 使用字面量添加新方法
SubType.prototype = {
getSubValue: function() {
return this.subProperty;
},
someOtherMethodL: function() {
return false;
}
}
var instance = new SubType();
alert(instance.getSuperValue()) // error
原型链的问题
原型链很强大，可以用它来实现继承，但它也存在一些问题。
其中，最主要的问题来自包含该引用类型值的原型：会被所有实例共享。
在通过原型来实现继承时，原型实际上行会变成另一个类型的实例。于是，原先的实例属性也就变成了原型的属性了。
function SuperType() {
this.colors = ["red", "blue", "green"];
}
function SubType() {}
// 继承了 SuperType
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push("black");
alert(instance1.colors); // red,blue,green,black
var instance1 = new SubType();
alert(instance1.colors); // red,blue,green,black
原型链的第二个问题是： 在创建子类实例时，不能向超类型的构造函数中传递参数。（无法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。）
