原型继承
function SuperType () {
this.property = true;
}
SuperType.prototype.getSuperValue = function () {
return this.property;
};
function SubType () {
this.subProperty = false;
}
// 继承SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubType = function () {
return this.subProperty;
};
var instance = new SubType();
// 原型链的问题
-- 包含引用类型值的原型属性会被所有的实例共享，通过原型来实现继承时，原型实际上会变成另一个类型的实例，于是原先的实力属性也就顺理成章的变成了现在的原型属性了
function SuperType () {
this.colors = ['red', 'yellow', 'green'];
}
function SubType () {}
// 继承SuperType
SubType.prototype = new SuperType();
var instance1 = new SubType();
instance1.colors.push('black');
var instance2 = new SubType(); // red,yellow,green,black
-- 创建子类型的实例的时候，不能像超类型的构造函数中传递参数
借用构造函数
// 借用构造函数
function SuperType () {
this.color = ['red', 'blue', "green"];
}
function SubType () {
// 继承SuperType
SuperType.call(this);
}
借调了超类的构造函数，在新创建的SubType实例的环境下调用了SuperType构造函数，在新的SubType对象上执行了SuperType()函数中定义了所有的对象初始化代码，结果每一个SubType的每一个实例都会具有自己的colors属性副本了
优势：
子类构造函数可以向父类构造函数传递参数
缺点：
方法都在构造函数中定义，因此函数复用就无从谈起了
组合继承
// 组合继承
function SuperType (name) {
this.name = name;
this.colors = ["red", "black", "blue"];
}
function SubType() {
SuperType.call(this);
}
SubType.prototype = new SuperType();
不同的SubType实例既分别拥有自己的属性，又可以使用相同的方法了
原型式继承
function object(o) {
function F() {};
F.prototype = o;
return new F();
}
不过引用类型值得属性始终都会共享相应的值
寄生式继承
创建一个封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像是它真的做了所有工作一样返回对象。
function createAnother(origin) {
var clone = object(origin);
clone.sayHi = function () {
//...
}
return clone;
}
寄生组合继承
优点： 因为组合继承最大的问题是无论什么情况下，都会调用两次超类构造函数 一次是创建子类原型的时候，另外一次就是在子类型构造函数内部。
寄生组合继承原理：
通过借用构造函数来继承属性，通过原型链的混成形式来继承方法
不必为了指定子类型的原型而调用超类型的构造函数，所需要的无非是超类型原型的一个副本而已。
function inheritPrototype(subType, superType) {
var prototype = object(superType.prototype);
prototype.constructor = subType;
subType.prototype = prototype;
}