继承-类式继承、原型继承、掺元继承

类式继承
当前最常用的继承方式，是对真正基于类的继承的一种模仿（此文代码参考自js设计模式，此方法也就是js高级程序设计中的组合继承）。

function extend(subClass, superClass){//模仿类继承方法
    var F = function(){};
    F.prototype = superClass.prototype;
    subClass.prototype = new F();
    subClass.prototype.constructor = subClass;
    
    subClass.super = superClass.prototype;//子类可以调用父类
    if (superClass.prototype.constructor == Object.prototype.constructor){
        superClass.prototype.constructor = superClass;
    }
}

function Person(name){//父类
    this.name = name;
}
Person.prototype.getName = function(){
    return this.name;
}

function Author(name, books){//子类
    Author.subClass.super.constructor.call(this, name);
    this.books = books;
}
extend(Author, Person);
//继承后，Author已有getName方法，也可Author.subClass.super.getName调用父类方法
Author.prototype.getBooks = function(){//Author新方法
    return this.books;
}

原型继承
js特有的继承模式，更能节省内存，因为不想类那继承那么好理解，所以用的较少。

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

var FatherObject = {};//父对象
FatherObject.string1 = 'default value';
FatherObject.createChildObject = function(){
    return {
        bool : true,
        num : 10
    }
}
FatherObject.childObject = FatherObject.createChildObject();//父对象的子对象

var sonObject = clone(FatherObject);//继承
sonObject.createChildObject();
sonObject.childObject.num = 5;

掺元继承
并不是严格的继承，是一种扩充，把一个共用方法扩充到很多个类中。间接的实现了子类继承多个父类。

function augment(receivingClass, givingClass){
    if (arguments[2]){//如果存在第3个参数（继承指定方法，并非全部）
        for (var i = 2, len = arguments.length; i < len; i++){
            receivingClass.prototype[arguments[i]] = givingClass.prototype[arguments[i]];
        }
    }else{//继承全部方法
        for (methodName in givingClass.prototype){
            if (!receivingClass.prototype[methodName]){
                receivingClass.prototype[methodName] = givingClass.prototype[methodName];
            }
        }
    }
}

var Mixin =  function(){}//共用方法
Mixin.prototype = {
    //...
}
augment(Author, Mixin, 'method1');//Author继承了Mixin中的method1方法