JavaScript的继承--组合继承

组合继承

组合继承也叫伪经典继承，指的是讲原型链和伪造对象的技术组合到一块，从而发挥两者之长的一种继承模式。
这种技术的思路是使用原型链实现对原型属性和方法的继承，使用伪造对象实现对实例属性的继承。这样，既通过原型上定义方法实现了函数复用，又能保证每个实例都有它自己的属性。

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);
    //实例属性
    this.age = age;
}

//继承方法
SubType.prototype = new 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("Gerg", 27);
console.log(instance2.colors); //"red, blue, green"
instance1.sayName();           //"Gerg"
instance1.sayAge();            //27

在这个例子中，SuperType构造函数定义了两个属性：name和colors。SuperType的原型定义了一个方法sayName。 SubType构造函数在调用SuperType构造函数时传入了name参数，然后定义了它自己的属性age。然后，将SuperType的实例赋值给SubType的原型，在新原型上定义方法sayAge。这样，就让两个不同的SubType实例既分别拥有自己的属性name, age, colors，又复用了方法。
组合继承的图解如下：

优势

与伪造对象相比，组合继承最大的优点在于实现了函数的复用，不管是子类型还是超类型，方法都是在原型中定义的，而子类型的实例可以分别拥有自己的属性，并且可以复用方法。

问题

与原型链一样，在将SuperType的实例对象赋值给SubType.prototype的时候，调用了一次SuperType的构造函数，从而使得SubType.prototype会得到两个原型属性：name & colors，其中name为undefined，colors为[“red”, “blue”, “green”]； 这两个属性都是SuperType的实例属性，在赋值之后，变为了SubType的原型属性。在调用SubType构造函数的时候，会再次调用一次SuperType构造函数，这样在SubType的实例对象上面会新创建实例属性name & colors，instance1的name为”Nicholas”， colors为[“red”, “blue”, “green”]。这两个实例属性就屏蔽了原型中的两个同名属性。从而使得实例对象在进行属性搜索的时候可以得到正确的结果。
然而，实际上SubType prototype里面的name & colors属性是不是完全没有必要存在，而组合继承方式却创建了？这就是组合继承方式的问题，在调用SuperType构造函数生成SuperType实例对象给SubType.prototype赋值的时候，生成了不必要的SubType.prototype的原型属性。
解决这个问题的方法是：寄生组合式继承。