js 类的继承

1. 方法一：
   通过使用构造函数，prototype，inherit 和 method 方法来实现类的继承；

//定义一个通用的 clone 函数，用来克隆一个新对象，该新对象以参数传入 的对象为原型；
function clone(object){
    function OneShotConstructor(){};
    OneShotConstructor.prototype = object; // 将对象做为构造函数的原型；
    return new OneShotConstructor();
}

//定义 inherit 和 method 方法

// 通过参数传入构造函数，以其原型克隆出一个对象，并将其作为当前对象的原型，实现了继承；
Object.prototype.inherit = function(baseConstructor){
    this.prototype = clone(baseConstructor.prototype);
    this.prototype.constructor = this;
}


// 给对象定义了一些 method 的方法，该方法使得对象可以将传入的函数，添加成为它自己的方法；
Object.prototype.method = function(name, func){
    this.prototype[name] = func;
}

//写个例子
function Item(name){
    this.name = name;
};

Item.prototype.inspect = function(){
    alert("It is " + this.name + ".");
};

Item.prototype.kick = function(){
    alert("Klunk!");
};

Item.prototype.take = function(){
    alert("you cannot lift " + this.name + ".");
};

var lantern = new Item("the brass lantern");

function DetailedItem(name, details){
    this.name = name;
    this.details = details;
};

DetailedItem.inherit(Item);

DetailedItem.method("inspect", function(){
    alert("you see " + this.name + "," + this.details + ".");
});

var giantSloth = new DetailedItem("the giant sloth",
                                    "it is quietly hanging from a tree, munching leaves");
                                    
function SmallItem(name){
    this.name = name;
};

SmallItem.inherit(Item);

SmallItem.method("kick", function(){
    alert(this.name + " files across the room.");
});

SmallItem.method("take", function(){
    alert("you take " + this.name + ".");
});

var pencil = new SmallItem("the red pencil");
pencil.kick();

2. 方法二：
   把原型放到一个对象中做为类，然后通过 create 方法来实例化，通过 extend 来创建子类；
   这种方法的好处是可以忽略 prototype 的使用；

//定义 extend 和 create 方法

// 给对象定义了一个 create 方法，该方法使得对象可以复制一个子对象出来；并且这个子对象还会
// 根据传入的参数，调用继承自父对象的 construct 方法，进行自己的初始化；
Object.prototype.create = function(){
    var object = clone(this); 
    if (object.construct != undefined)
        object.construct.apply(object, arguments); 
    return object;
}


// 给对象定义了一个 extend 方法，该方法会创建一个子对象，并将传入的对象的所有属性，复制一份到子对象上；
Object.prototype.extend = function(properties){
    var result = clone(this);
    forEachIn(properties, function(name, value){
        result[name] = value;
    });
    return result;
}



//写个相同的例子
var Item = {
    construct: function(name){
        this.name = name;
    },  
    inspect: function(){
        alert("It is " + this.name + ".");
    },  
    kick: function(){
        alert("Klunk!");
    },
    take: function(){
        alert("You cannot lift " + this.name + ".");
    }
}

var lantern = Item.create("the brass lantern");

var DetailedItem = Item.extend({
    construct: function(name, details){
        Item.construct.call(this, name);
        this.details = details;
    },
    inspect: function(){
        alert("you see " + this.name + "," + this.details + ".");
    }
});

var giantSloth = DetailedItem.create("the giant sloth", 
                                    "it is quietly hanging from a tree, munching leaves");
                                    
var SmallItem = Item.extend({
    kick: function(){
        alert(this.name + " files across the room.");
    },
    take: function(){
        alert("you take " + this.name + ".");
    }
});

var pencil = SmallItem.create("the red pencil");
pencil.take();

总结：不管是第1种的 inherit 方法，还是第二种的 create 方法，它们都是通过将父对象做子对象的原型来实现的继承，区别在后者对 prototype 的使用进行了封装，不需要老是打 protoype 这个单词， 降低了出错概率，更好的实现了概念的抽象；