继承

原型继承

 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;
    }