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 这个单词， 降低了出错概率，更好的实现了概念的抽象；