JavaScript对象（3）——继承

3. 继承

许多OO语言都支持两种继承方式：接口继承和实现继承。接口继承只继承方法签名，而实现继承则继承实际的方法。由于函数没有签名，在ECMAScript中无法实现接口继承。ECMAScript只支持实现继承，而且其实现继承主要是依靠原型链来实现的。

3.1 原型链

原型链继承有一种基本的模式：

function SuperType(){
    this.property = true;
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}
function SubType(){
    this.property = false;
}
//继承SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValues = function(){
    return this.prototype;
}

var instance = new SubType();
alert(instance.getSuperType());             //true

在上面的代码中，没有使用SubType默认提供的原型，而是给它换了一个新原型；这个新原型就是SuperType的实例。于是，新原型不仅具有作为一个SuperType的实例所拥有的全部属性和方法，而且其内部还有一个指针，指向了SuperType的原型。最终结果是：instance指向SubType的原型，而SubType的原型又指向SuperType的原型。 

注意：因为SubType.prototype被重写，丢失了默认的constructor属性，导致instance.constructor现在指向的是SuperType。

原型链存在的问题：在实现原型继承的时候，原型实际上是变成了另一个类型的实例，原先的实例属性成为现在原型的属性，原型属性会被所有的实例共享，进而造成包含引用类型值的原型。

function SuperType(){
    this.property = true;
    this.colors = ["red","blue"];
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}
function SubType(){
    this.property = false;
}
//继承SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValues = function(){
    return this.prototype;
}

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

var instance2 = new SubType();
console.log(instance2.colors);      //"red,blue,green"  

这个例子中的SuperType构造函数定义了一个colors属性，该属性包含一个colors属性，该属性包含一个书序（引用类型值）。SuperType的每个实例都会有各自包含自己数组的colors属性。当SubType通过原型链继承了SuperType之后，SubType.prototype就变成了SuperType的一个实例，因此它也拥有了一个自己的colors属性。结果造成了SubType所有的实例都会共享colors属性。

原型链的第二个问题是：在创建子类型的实例时，不能向超类型的构造函数中传递参数。实际上是，没有办法在不影响所有对象实例的情况下，给超类型的构造函数传递参数。

因为原型链继承中存在以上两个问题，所以，实践中很少会单独使用原型链。

3.2 借用构造函数

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

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

var instance2 = new SubType();
console.log(instance2.colors);      //"red,blue"    

借用构造函数可以传递参数。

function SuperType(name){
    this.name = name;
}
function SubType(name){
    //继承了SuperType
    SuperType.call(this,name);
}
var instance = new SubType("Nicholas");
console.log(instance.name);     //"Nicholas"

借用构造函数模式存在的问题：无法实现函数复用；子类型智能获取超类型构造函数上 的属性和方法，无法获取超类型的原型上的属性和方法。

借用构造函数模式在实践中也很少单独使用。

3.3 组合继承

组合继承：指的是将原型链额借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式。思路：使用原型链实现对原型属性和方法的继承，而通过借用构造函数来实现对实例属性的继承。

function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","green"];
}

SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType(name, age){
    SuperType.call(yhis,name);                      //第二次调用SuperType()
    this.age = age;
}

SubType.prototype = new SuperType();                //第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
}

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为Javascript中最常用的继承模式。而且，instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象。

3.4 原型式继承

基本思想：借助原型可以基于已有的对象创建新对象，同时还不必因此创建自定义类型。

function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

在object()函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回了这个临时类型的一个实例。从本质上讲，object()对传入其中的对象执行了一次浅复制。
例子如下：

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = object(person);
anotherPerson.name = "Greg";
anotherPerson.friends.push("Rob");

var yetAnotherPerson = object(person);
yetAnotherPerson.name = "Linda";
yetAnotherPerson.fiends.push("Barbie");

alert(person.friends);              //"Shelby,Court,Van,Rob,Barbie"

原型式继承，要求必须有一个对象可以作为另一个对象的基础。如果有这么一个对象的话，可以把它传递给object()函数，然后再根据具体需求对得到的对象加以修改即可。

ECMAScript5通过新增object.create()方法规范化了原型式继承。这个方法接收两个参数：一个用作新对象原型的对象和（可选的）一个为新对象定义额外属性的对象。在传入一个参数的情况下，Object.create()与object()方法行为相同。

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.fiends.push("Barbie");

alert(person.friends);           //"Shelby,Court,Van,Rob,Barbie"

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同：每个属性都是通过自己的描述符定义的。以这种方式是定的任何属性都会覆盖原型对象上的同名属性，例如：

var person = {
    name: "Nicholas",
    friends: ["Shelby", "Court", "Van"]
};
var anotherPerson = Object.create(person,{
    name:{
        value:"Greg"
    }
});
alert(anotherPerson.name);              //"Greg"

支持Object.create()方法的浏览器有IE9+、Firefox4+、Safari5+、Opera12+和Chrome。

如果只是想让一个对象与另一个对象保持类似的情况下，原型式继承是完全可以胜任的。但是，包含引用类型值的属性始终都会共享相应的值，就像使用原型模式一样。

3.5 寄生式继承

寄生式继承是与原型继承紧密相关的一种思路。
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。

function createAnother(original){
    var clone = object(original);            //通过调用函数创建一个新对象
    clone.sayHi = function(){                //以某种方式来增强这个对象
        alert("hi");
    };
    return clone;                            //返回这个对象
}

在这个例子中，createAnother()函数接收了一个参数，也就是将要作为新对象基础的对象。然后，把这个对象（original）传递给object()函数，将返回的结果赋值给clone。再为clone对象添加一个新方法sayHi()，最后返回clone对象。

var person={
    name: "Nicholas",
    friends: ["Shelby", " Court", "Van"]
};

var anotherPerson = createAnother(person);
anotherPerson.sayHi();                      //"hi"

这个例子中的代码基于person返回了一个新对象——anotherPerson。新对象不仅具有person的所有属性和方法，而且还有自己的sayHi()方法。
在主要考虑对象而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式。前面示范继承模式时使用的object()函数不是必需的；任何能够返回新对象的函数都适用于此模式。

使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率；这一点与构造函数模式类似。

3.6 寄生组合式继承

组合继承是JavaScript最常用的继承模式；不过，组合继承无论在什么情况下，都会调用两次超类型构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数内部。子类型最终会包含超类型对象的全部实例属性，但我们不得不在调用子类型构造函数时重写这些属性。
组合继承：

function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","green"];
}

SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType(name, age){
    SuperType.call(yhis,name);                      //第二次调用SuperType()
    this.age = age;
}

SubType.prototype = new SuperType();                //第一次调用SuperType()
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
}

在第一次调用SuperType构造函数时，SubType.prototype会得到两个属性：name和colors；它们都是SuperType的实例属性，只不过现在位于SubType的原型中。当调用SubType构造函数时，又会调用一次SuperType构造函数，这一次又在新对象上创建了实例属性name和colors。于是，这两个属性就屏蔽了原型中的两个同名属性。

寄生组合式继承解决了组合继承中的两次调用超类型的构造函数问题。
寄生组合式继承，是通过借用构造函数来继承，通过原型链的混成形式来继承方法。其背后的基本思路是：不必为了指定子类型的原型而调用超类型的构造函数，我们需要的仅仅是超类型原型的一个副本。本质上，是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

寄生组合式继承的基本模式：

function inheritPrototype(subType,superType){
    var prototype = object(superType.prototype);     //创建对象
    prototype.constructor = subType;                 //增强对象
    subType.prototype = prototype ;                  //指定对象
}

这个函数接收两个参数：子类型构造函数和超类型构造函数。在函数内部，第一步是创建超类型原型的一个副本。第二步是为创建的副本添加constructor属性，从而弥补因重写原型而失去的默认的constructor属性。最后一步，将新创建的对象（即副本）赋值给子类型的原型。这样，我们就可以调用inheritPrototype()函数的语句，去替换前面例子中为子类型原型赋值的语句了。
寄生组合式继承：

function SuperType(name){
    this.name = name;
    this.colors = ["red","blue","green"];
}

SuperType.prototype.sayName = function(){
    alert(this.name);
};

function SubType(name, age){
    SuperType.call(yhis,name);  
    this.age = age;
}

inheritPrototype(SubType,SuperType);
SubType.prototype.constructor = SubType;
SubType.prototype.sayAge = function(){
    alert(this.age);
}

这个例子的高效率体现在它只调用了一次SuperType构造函数，并且避免了在SubType.Prototype上面创建不必要、多余的属性。与此同时，原型链还能保持不变；因此，还能够正常使用instanceof和isPrototypeOf()。开发人员普遍认为寄生组合式继承是引用类型最理想的继承范式。

本文章参考总结 ->JavaScript高级程序设计（第三版）