- 方法一：
通过使用构造函数，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();
- 方法二：
把原型放到一个对象中做为类，然后通过 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 这个单词， 降低了出错概率，更好的实现了概念的抽象；
