javascript有所帮助。
<html>
<head>
<script type="text/javascript" src="base.js"></script>
<script type="text/javascript">
var car2 = {
name:"轿车【父类】",
price:"几万【父类】",
start : function(){
alert(this.name+" 已启动2！【父类】");
},
run : function(){
alert(this.name+" 在行驶当中2。。。【父类】");
},
stop: function(){
alert(this.name+" 已停止2！【父类】");
},
remark: function(){return "【父类】2我是一辆 "+this.name+"；价值 "+this.price;}
// this.remark = "我是一辆 "+this.name+"；价值 "+this.price;
}
//car2.prototype.extra = function(ext){
// return this.name+" 的关税2是："+ext;
//}
car2.protect = "【父类】2保护的";
car2.noextra = function(){
return car.protect+" 不交关税2【父类】";
}
var car = function(name,price){
this.name=name||"轿车 [父类]";
this.price=price||"几万[父类]";
this.start = function(){
alert(this.name+" 已启动！[父类]");
};
this.run = function(){
alert(this.name+" 在行驶当中。。。[父类]");
};
this.stop= function(){
alert(this.name+" 已停止！[父类]");
};
this.remark = function(){return "[父类]我是一辆 "+this.name+"；价值 "+this.price;};
// this.remark = "我是一辆 "+this.name+"；价值 "+this.price; //注意，这样做 name 和price 将得不到传参，故注释
}
car.prototype.extra = function(ext){
return this.name+" 的关税是[父类]："+ext;
}
car.protect = "[父类]保护的";
car.noextra = function(){
return car.protect+" 不交关税[父类]";
}
var bmw = function(){
this.extendf(bmw,car);
this.name = "bmw【子类】";
this.start=function(){
alert(this.name+"专属 启动装置！");
};
return ("this.name1="+this.name);
}
var bmw2 = function(){
this.extendf(bmw2,car2);
this.name = "宝马终极2号【子类】";
this.start=function(){
alert(this.name+" 专属 启动装置2号未来！");
};
return ("this.name1="+this.name);
}
var bensi = {
name:"bensi",
price:"130万",
start:function(){
alert(this.name+" 华丽启动！");
},
stop:function(){
alert(this.name+" 专用刹车停止！");
}
}
bensi.noextra=function(){
return "谁敢收税？";
}
var autuo = {
name:"autuo【子类】",
price:"1万",
stop:function(){
alert(this.name+" 奥拓失灵了！");
}
}
function changan(){
this.extendf(changan,car);
// this.name = "changan【子类】";
this.run=function(){
alert(this.name+" 走的有点慢。。。");
}
}
var ftest = function(){
var tb = new bmw("宝马","70万");
testrun(tb);
alert(bmw.noextra());
}
var ftest2 = function(){
var tb = bensi//("奔驰","120万");
tb.extendf(bensi,car);
testrun(bensi);
alert(bensi.noextra());
}
var ftest3 = function(){
var tb = new changan("长安[传参]","5万");
testrun(tb);
alert(changan.noextra());
}
var ftest4 = function(){
var tb = autuo
tb.extendf(autuo,car2);
testrun(tb);
alert(autuo.noextra());
}
var ftest5 = function(){
var tb = autuo
tb.extendf(autuo,bensi);
alert(tb.name);
tb.start();
tb.stop();
alert(autuo.noextra());
}
var ftest6 = function(){
var tb = new bmw2("宝马2号","65万");
var scar = document.getelementbyid("showcar");
scar.innerhtml = tb.remark();
alert(tb.name);
tb.start();
tb.stop();
alert(bmw2.noextra());
}
//测试输出
function testrun(tb){
var scar = document.getelementbyid("showcar");
if(!scar) return false;
scar.innerhtml = tb.remark();
tb.base.start();
tb.start();
tb.base.run();
tb.run();
tb.base.stop();
tb.stop();
alert(tb.extra("1万"));//父类为object时这个会出错，因为父类本身就没有
}
</script>
</head>
<body>
js测试：
<input type = "button" value = "宝马" onclick = "ftest()" >
<input type = "button" value = "奔驰" onclick = "ftest2()" >
<input type = "button" value = "长安" onclick = "ftest3()" >
<input type = "button" value = "奥拓" onclick = "ftest4()" >
<input type = "button" value = "奔驰类的奥拓" onclick = "ftest5()" >
<input type = "button" value = "宝马2号" onclick = "ftest6()" >
<div id = "showcar"></div>
</body>
</html>object.prototype.extendf= function (a,b){
if(!a||!b) return;
var fa = typeof a=="function";
var fb = typeof b=="function";
var cha = function(a,b){
for(var c in b){
if(a[c]==undefined)//子类重写
a[c]=b[c];
}
return a;//返回继承后的对象
}
if(fa&&fb){
b.apply(this,a.arguments);
cha(a,b);
this["base"] =new b;//通过base访问父类
return cha(this,b.prototype);
}
else if(!fa&&fb){
cha(a,new b);
a["base"]= new b;
return cha(a,b);
}else if(fa&&!fb){
cha(a,b);
this["base"]=b;
return cha(this,b);
}else if(!fa&&!fb){
a["base"]=b;
return cha(a,b);
}
}
javascript本身是从perl语言的语法演变而来的，本质上是脚本语言，随着版本的更新逐渐加入的对面向对象的模拟。我认为js的面向对象模拟总体上做得还是不错的，因为我们不能盲从任何一种理念，不能纯粹的为了oop而oop，我们需要抓住的是面向对象的好处到底是什么？为了这些优点去oop，才是最明智的选择，所以说js做得还不错。
js的继承在很多书里面细致的分了很多种类型和实现方式，大体上就是两种：对象冒充、原型方式。这两种方式各有优点和缺陷，这里我先列举出来，再从底层分析区别：
(一)对象冒充
jscript code
function a(name){
this.name = name;
this.sayhello = function(){alert(this.name+” say hello!”);};
}function b(name,id){
this.temp = a;
this.temp(name); //相当于new a();
delete this.temp; //防止在以后通过temp引用覆盖超类a的属性和方法
this.id = id;
this.checkid = function(id){alert(this.id==id)};
}
首页 1 2 末页