1

Javascript面向对象总结

Posted by 晴云孤魂 on 2011 年 02 月 17 日 in web development |

Javascript的关键特征及其含义
l. 变量是弱类型的(loosely typed):变量仅仅声明为变量,没有数据类型,给同一个变量分配不同的类型是合法的。
2.代码是动态解释的:不需要预编译,以文本形式保存并在程序运行时解释为机器指令。
3.Javascript函数是正常对象:Java的方法总与拥有它的对象绑在一起。
4.Javascript对象是基于prototype的:Java有超类、接口等,Prototype在Javascript中用来模拟Java风格的类型,但只是表面相似而已。

Javascript中的对象。
创建一个新的JavaScript对象的简单方法是调用Object类内建的构造函数:var myObject=new Object();
创建即时对象
Javascript对象本质上是一个关联数组,由以名称作为键的字段和方法组成。有两种即时方式创建对象。一种是直接使用JavaScript创建对象,另一种是用JSON来创建。
1.使用JavaScript语句
myObject.shoeSize=”12”;//或myObject[‘shoeSize’]=”12”;将一个属性添加到刚才创建的对象上。
myObject.speakYourShoeSize=function(){ //将一个函数动态添加到一个对象。
alert(“shoe size :”+this.shoeSize);
}
function sayHello(){
alert(‘hello,my shoeSize is’+this.shoeSize);
}
myObject.sayHello=sayHello; //将一个函数动态添加到一个对象

2.使用JSON
var myLibrary={
location:”my house”,
keywords:[“root vegetables”,”turnip”,”tedium”],
summarize:function(){…..}
};
或以混合匹配使用Javascript和JSON符号:
var cookbook=new Object();
cookbook.pageCount=321;
cookbook.author={

};

构造函数、类和prototype属性
构造函数:
function Myobject(name,size){
this.name=name;
this.size=size;
this.tellSize=function(){ //创建了闭包,这对内存回收不利。
alert(“size of ”+this.name+” is ”+this.size);
}
}
var myObj=new Myobject(“tiddles”,”7.5 meters”);
myObj.tellSize();
使用Prototype关联对象属性,函数。
function Myobject(name,size){
this.name=name;
this.size=size;
}
Myobject.prototype.tellSize=function(){…..}
Myobject.prototype.color=”red”;
var myObj=new Myobject(“tiddles”,”7.5 meters”);
myObj.tellSize();

扩展内建对象(extends)
在Web浏览器中,DOM节点在IE浏览器中不能扩展,但是其他的核心类在所有主要的浏览器中都是可以扩展的。以Array类为例子。
Array.prototype.indexOf=function(obj){ //添加一个返回给定数组中对象的数字索引
var result=-1;
for(var i=0;i

if(this[i]==obj){
result=I;
break;
}
}
return result;
}

继承
Ajax实战并没有实例,这里选取一些已经验证过的方法
1.在运行时给对象分配任意的属性:
function ClassA() {
this.color = ‘red’;
this.sayColor = function(){
alert(this.color);
}
}
function ClassC() {
this.newMethod = ClassA; //在运行时给对象分配任意的属性,
this.newMethod(); //如果ClassA的构造函数有参数,在这里传入
delete this.newMethod; //删除对ClassA的引用,避免以后被调用
}
function test(){//验证
var c=new ClassC();
c.completelyNewProperty=”something”;//在运行时给对象分配任意的属性,
alert(c.newMethod);
c.sayColor();
alert(c.completelyNewProperty); // alert(“something”);
}
2.使用Prototype链:
function ClassA() {}
ClassA.prototype.color = “red”;
ClassA.prototype.sayColor = function() {
alert(this.color);
}

function ClassB(){}
ClassB.prototype = new ClassA();
ClassB.prototype.name = “who”;
ClassB.prototype.sayName = function() {
alert(this.name);
}
function test(){
var b=new ClassB();
b.sayColor();
b.sayName();
}
3.使用call方法:
function ClassA(sColor) {
this.color =sColor;
this.Name =’name’;
this.sayColor = function() {
alert(this.color);
}
this.sayName = function() {
alert(this.Name);
}
}
function ClassB(sColor){
ClassA.call(this, sColor);
}
function test(){
var b=new ClassB(‘red’);
b.sayColor(); //alert(‘red’)
b.sayName(); //alert(‘name’);
}

javaScript对象的反射(了解对象拥有的属性或方法)
1.了解一个对象是否支持一个特定的属性或者方法:
if(MyObject.someProperty){…}//如果MyObject.someProperty的值为false、数字0或者null,无法进入if语句体
更加严格的测试应用这样写:
if(typeof(MyObject.someProperty)!=’undefined’){…}
如果关心属性的类型:
if(myobj instanceof Array){…}

2.查看一个对象的所有属性和函数:
var debug=’discovering…\n’;
for(var I in myobj){
debug+=i+’ ->’+myobj[i]+’\n’;
}
alert(debug);

接口和“鸭子类型”
我们经常说接口在不同的软件组件之间定义了一个契约。接口提供了好的概念分离,并且支撑了很多的设计模式。一个对象是否实现了一个接口,要看它是否实现了接口的方法(方法包括:方法名、参数和返回值)
1.是否有特定名称的函数:
function implements(){
this.implement=function(obj,funcName){
return obj && obj[funcName] && obj[funcName] instanceof Function;
}
}
2.是否遵守了一个完整的接口:
function isShape(obj){
var imp=new implements();
return imp.implement(obj,”getArea”)&& imp.implement(obj,”getPerimeter”);
}
3.参数和返回值类型是否一致(以是否为float类型为例子):
function isNum(arg){
return parseFloat(arg)!=NaN;//NaN:为非数的简写
}

方法和函数
Javascript函数是自由浮动的实体,自身就可以作为正常对象(静态的Java方法位于这两者之间-它并没有捆绑在任何对象实例上,但是仍然捆绑在类的定义上)。在Javascript中Function是一个内建的对象类型。JavaScript函数的参数列表的长度不固定,且忽略任何额外的参数,并给缺少的参数赋值undefined。一个智能的函数可以通过arguments属性查询它自已的参数列表,并为缺少的值分配默认值、抛出一个异常或采取其他的补救措施。如:
function Dish(){
this.say=function(){
alert(arguments[0]);
}
}
Dish.prototype.description=function (){ //使用Dish.description会出错,因为Dish还不是对象
for( var i = 0; i < arguments.length; i++ ){
alert(arguments[i]);
}
}
function test(){
var dish=new Dish();
dish.say(‘s’);
dish.say(‘a’,’y’); //这个方法可以执行,可变参数
dish.description(‘descript’);
dish.description(‘value’,’value2’);//这个方法不可以执行,通过prototype捆绑的方法,执行带参方法后,此方法无效了
}
//getter或setter方法
function area(value){
if(value){this.area=value;}
return this.area;
}

向对象附加函数
定义函数:
function doSomething(x,y,z){…}
或:
var doSomething=function(x,y,x){…}
myObj.doSomethingNew=doSomething;// 附加到对象:
myObj.doSomethingNew(x,y,z);//调用方法

从其他对象借用函数(借用函数,通过这种方式可以模拟继承)
1.定义一个树类
function Tree(name,leaf,bark){
this.name=name;
this.leaf=leaf;
this.bark=bark;
}
2.添加一个函数
Tree.prototype.describe=function(){
return this.name+”: leaf=”+this.leaf+”,bark=”+this.bark;
}
3.实例化一个Tree对象
var Beech=new Tree(‘Beech’,”green,serrated edge”,’smooth’);
alert(Beech.describe());
4.定义一个类表示狗
function Dog(name,bark){
this.name=name;
this.bark=”wau! wau!”;
}
5.实例化一个Dog类
var Snowy=new Dog(“Snowy”,”wau!wau!”);
6.借用函数
var temFunc=Beech.describe;
tmpFunc.call(Snowy);//Function.call()第一个参数是上下文对象。狗狗借用describe()方法。方法中的this被改了,由于Dog没有leaf属性,所以leaf的值为:undefined;

javascript中的闭包
关于闭包,最简单的描述就是 ECMAScript 允许使用内部函数--即函数定义和函数表达式位于另一个函数的函数体内。

Java代码
function Robot(){
var createTime=new Date();
this.getAge=function(){
var now=new Date();
var age=now-createTime;
return age;
}
}
function Robot(){
var createTime=new Date();
this.getAge=function(){
var now=new Date();
var age=now-createTime;
return age;
}
}

闭包仅仅当内部函数创建在外部函数之内的时候才可以运行,因为它使用了外部函数的局部变量。这样的话使得局部变量不能被垃圾器收集,会造成内存泄漏。闭包的替代方法,就是避免使用它,方法:
function Robot(){
this.createTime=new Date();
}
Robot.prototype.getAge=function(){
var now=new Date();
var age=now-createTime;//createTime是一个可以访问的变量
return age;
}

Copyright © 2011-2021 晴云孤魂's Blog All rights reserved.
This site is using the Desk Mess Mirrored theme, v2.5, from BuyNowShop.com.

普人特福的博客cnzz&51la for wordpress,cnzz for wordpress,51la for wordpress