js面向对象学习
2010年11月10日
js参考:http://www.iselong.com/online/ebooks/javascript/
1.数据类型
基本数据类型
Number, String, Boolean, Function, Object, Array, null, undefined(注意null和undefined的区别),
日期和时间
Date
正则表达式
RegExp:new RegExp()=/[1-9][0-9]*/;JavaScript中,一对斜线中包括一个文本就认为构成了一个正则表达式对象
错误对象
JavaScript中定义了几个用于处理错误类型的类,有:Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError。和Java中的异常处理方式类似,JavaScript中的错误对象可以用try...catch...finally语句来处理.
2.函数
函数的参数:arguments对象,在一个函数中,会有一个隐含的arguments对象来保存函数的参数,这样在有些时候,我们在定义函数时,可以不明确指定函数所需要的参数.
如:
// 求最大值
function max() {
var m = Number.NEGATIVE_INFINITY; // 无穷小
for (var i = 0; i m)
m = arguments[i];
}
return m;
}
// 测试
var largest = max(1, 7, 9, 23, 88, 2, 5);
alert(largest);
3.封装的实现
Human = function(name) // 等于function Human(name)
{
var me = this;
// 私有属性
var _name = null;
// 公有属性
me.name = null;
// 私有方法,可用来定义构造函数
function setName()
{
_name = name;
me.name = _name;
}
// 公有方法
me.sayHello = function()
{
alert("Hello, my name is " + me.name);
}
// 模拟构造函数
function constructor()
{
setName();
}
constructor();
return me;
}
// 增加类的静态方法,在类定义的外部增加
Human.classMethod = function()
{
alert("Human's classMethod");
}
// 通过原型(prototype)增加公有方法
Human.prototype.sayGoodbye = function()
{
alert("Goodbye, " + this.name);
}
// 当成类来使用
var m_human = new Human("pengfei");
m_human.sayHello();
// 调用类的静态方法
Human.classMethod();
// 直接当成函数使用
Human("huang");
JavaScript语言中类的定义和函数的定义都是使用function关键字
a 私有属性和方法的定义,直接在类内部定义一个变量,因为这个变量的作用域只限定在类内部,外部不能使用,因此这样定义的属性是私有属性,私有方法的定义也类似。
b 公有属性和方法的定义,通过定义一个私有变量me等于this,然后动态添加me变量的属性和方法,最后把me变量作为创建的实例对象返回。这样给me变量添加的属性和方法在类外部可以使用,也就是公有属性和方法。
c 构造函数的定义,构造函数是在创建一个对象时,自动执行的一个函数。在Java,C#等面向对象的语言中,只要定义一个函数和类名相同即可。在JavaScript中,可以随便定义一个私有函数,这个函数需要在类定义体中执行,这样的函数即成为构造函数,需要注意的是,为了确保构造函数中的代码都已经被解释过,构造函数最好放在类定义的最后。
d 类静态方法的定义,类静态方法是指不需要通过类实例来调用,而是可以直接通过类名来调用的方法。在Java,C#等面向对象语言中,一般是通过关键字static来指明一个方法是静态方法。在JavaScript中,没有static关键字,不能在类的定义体中实现静态方法,必须在类的定义体外,通过直接在类上动态添加方法来定义静态方法。需要注意,JavaScript静态方法中不能访问类的公有属性和公有方法,这和Java,C#等语言是一致的。
e 类的公有属性和公有方法也可以使用prototype来实现, 但是使用prototype有以下几个注意点:需要定义在类定义体外,和Java等语言的封装习惯不一致;prototype方式不能访问类的私有属性。
f JavaScript不能实现只读属性、只写属性的定义,所有的公有属性都是可读可写。
4.继承的实现
JavaScript中的继承都是通过JavaScript语言本身的特性模拟出来的,可以通过两种方式实现继承
1)创建对象方式
// 定义父类
Human = function()
{
var me = this;
me.name = "";
me.age = 0;
me.setName = function(name)
{
me.name = name;
}
me.setAge = function(age)
{
me.age = age;
}
me.sayHello = function()
{
alert("Human sayHello, name:"+ me.name +", age:"+ me.age);
}
return me;
}
// 定义子类
Chinese = function(name, age)
{
// 继承
var me = new Human();
// 覆盖父类的sayHello方法
me.sayHello = function()
{
alert("中国人问好,名字:"+ me.name +",年龄:"+ me.age);
}
// 设置name和age
me.setName(name);
me.setAge(age);
return me;
}
// 测试
var c = new Chinese("李四", 21);
c.sayHello();
定义一个变量me,赋予父类实例,这样me就有了父类的属性和方法,然后给me增加子类的属性和方法,最后把me变量作为创建的实例对象返回。这样定义的类就有了父类的属性和方法,即实现了继承
2)原型(prototype)方式
// 定义父类
function Human()
{
this.name = "";
this.age = 0;
}
Human.prototype =
{
setName : function(name)
{
this.name = name;
},
setAge : function(age)
{
this.age = age;
},
sayHello : function()
{
alert("Human sayHello, name:"+ this.name +", age:"+ this.age);
}
}
// 定义子类
function Chinese(name, age)
{
this.setName(name);
this.setAge(age);
}
// 继承
Chinese.prototype = new Human();
// 覆盖父类的sayHello方法
Chinese.prototype.sayHello = function()
{
alert("中国人问好,名字:"+ this.name +",年龄:"+ this.age);
}
// 测试
var c = new Chinese("张三", 20);
c.sayHello();
首先封装好子类的属性和方法,然后创建一个父类实例附给子类的prototype属性,这样子类就有了父类的属性和方法,即实现了继承
3)javaScript模拟的继承还要以下问题:
a 不能定义保护的方法和属性。
b 不能继承父类的静态方法。
5.多态的实现
1)重载
由于JavaScript的弱类型性,JavaScript在定义函数时,不需要指定函数参数的类型和个数,这种特性为重载的实现提供了便利。如:
function say(param)
{
// 通过typeof函数,判定不同类型的参数。
if (typeof(param)=="string")
alert("string");
else if (typeof(param)=="number")
alert("number");
else
alert("others");
}
JavaScript中另外一种比较常见的重载方式是通过函数的arguments对象来实现,这种方式已在前面讲过,不再赘述.
2)JavaScript中覆盖的实现,只需在子类中定义一个与父类同名的方法即可。
6.静态类的实现
静态类,是一种不能被实例化,并且只包含有静态成员的类,可以通过实例化匿名函数来实现静态类new function(0.
UtilTool = new function() // 关键在于这个new
{
var me = this;
// 增加一个静态方法
me.add = function(a, b)
{
return a+b;
}
return me;
}
// 测试
var sum = UtilTool.add(10, 100);
alert(sum);
UtilTool其实是一个对象,只是这个对象属于匿名类,该类在创建完UtilTool这个对象后,就不能再被使用了。而UtilTool是一个对象,不是一个 function,所以不能作为一个类被实例化,因此,它就相当于一个静态类。
2010年11月10日
js参考:http://www.iselong.com/online/ebooks/javascript/
1.数据类型
基本数据类型
Number, String, Boolean, Function, Object, Array, null, undefined(注意null和undefined的区别),
日期和时间
Date
正则表达式
RegExp:new RegExp()=/[1-9][0-9]*/;JavaScript中,一对斜线中包括一个文本就认为构成了一个正则表达式对象
错误对象
JavaScript中定义了几个用于处理错误类型的类,有:Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError。和Java中的异常处理方式类似,JavaScript中的错误对象可以用try...catch...finally语句来处理.
2.函数
函数的参数:arguments对象,在一个函数中,会有一个隐含的arguments对象来保存函数的参数,这样在有些时候,我们在定义函数时,可以不明确指定函数所需要的参数.
如:
// 求最大值
function max() {
var m = Number.NEGATIVE_INFINITY; // 无穷小
for (var i = 0; i m)
m = arguments[i];
}
return m;
}
// 测试
var largest = max(1, 7, 9, 23, 88, 2, 5);
alert(largest);
3.封装的实现
Human = function(name) // 等于function Human(name)
{
var me = this;
// 私有属性
var _name = null;
// 公有属性
me.name = null;
// 私有方法,可用来定义构造函数
function setName()
{
_name = name;
me.name = _name;
}
// 公有方法
me.sayHello = function()
{
alert("Hello, my name is " + me.name);
}
// 模拟构造函数
function constructor()
{
setName();
}
constructor();
return me;
}
// 增加类的静态方法,在类定义的外部增加
Human.classMethod = function()
{
alert("Human's classMethod");
}
// 通过原型(prototype)增加公有方法
Human.prototype.sayGoodbye = function()
{
alert("Goodbye, " + this.name);
}
// 当成类来使用
var m_human = new Human("pengfei");
m_human.sayHello();
// 调用类的静态方法
Human.classMethod();
// 直接当成函数使用
Human("huang");
JavaScript语言中类的定义和函数的定义都是使用function关键字
a 私有属性和方法的定义,直接在类内部定义一个变量,因为这个变量的作用域只限定在类内部,外部不能使用,因此这样定义的属性是私有属性,私有方法的定义也类似。
b 公有属性和方法的定义,通过定义一个私有变量me等于this,然后动态添加me变量的属性和方法,最后把me变量作为创建的实例对象返回。这样给me变量添加的属性和方法在类外部可以使用,也就是公有属性和方法。
c 构造函数的定义,构造函数是在创建一个对象时,自动执行的一个函数。在Java,C#等面向对象的语言中,只要定义一个函数和类名相同即可。在JavaScript中,可以随便定义一个私有函数,这个函数需要在类定义体中执行,这样的函数即成为构造函数,需要注意的是,为了确保构造函数中的代码都已经被解释过,构造函数最好放在类定义的最后。
d 类静态方法的定义,类静态方法是指不需要通过类实例来调用,而是可以直接通过类名来调用的方法。在Java,C#等面向对象语言中,一般是通过关键字static来指明一个方法是静态方法。在JavaScript中,没有static关键字,不能在类的定义体中实现静态方法,必须在类的定义体外,通过直接在类上动态添加方法来定义静态方法。需要注意,JavaScript静态方法中不能访问类的公有属性和公有方法,这和Java,C#等语言是一致的。
e 类的公有属性和公有方法也可以使用prototype来实现, 但是使用prototype有以下几个注意点:需要定义在类定义体外,和Java等语言的封装习惯不一致;prototype方式不能访问类的私有属性。
f JavaScript不能实现只读属性、只写属性的定义,所有的公有属性都是可读可写。
4.继承的实现
JavaScript中的继承都是通过JavaScript语言本身的特性模拟出来的,可以通过两种方式实现继承
1)创建对象方式
// 定义父类
Human = function()
{
var me = this;
me.name = "";
me.age = 0;
me.setName = function(name)
{
me.name = name;
}
me.setAge = function(age)
{
me.age = age;
}
me.sayHello = function()
{
alert("Human sayHello, name:"+ me.name +", age:"+ me.age);
}
return me;
}
// 定义子类
Chinese = function(name, age)
{
// 继承
var me = new Human();
// 覆盖父类的sayHello方法
me.sayHello = function()
{
alert("中国人问好,名字:"+ me.name +",年龄:"+ me.age);
}
// 设置name和age
me.setName(name);
me.setAge(age);
return me;
}
// 测试
var c = new Chinese("李四", 21);
c.sayHello();
定义一个变量me,赋予父类实例,这样me就有了父类的属性和方法,然后给me增加子类的属性和方法,最后把me变量作为创建的实例对象返回。这样定义的类就有了父类的属性和方法,即实现了继承
2)原型(prototype)方式
// 定义父类
function Human()
{
this.name = "";
this.age = 0;
}
Human.prototype =
{
setName : function(name)
{
this.name = name;
},
setAge : function(age)
{
this.age = age;
},
sayHello : function()
{
alert("Human sayHello, name:"+ this.name +", age:"+ this.age);
}
}
// 定义子类
function Chinese(name, age)
{
this.setName(name);
this.setAge(age);
}
// 继承
Chinese.prototype = new Human();
// 覆盖父类的sayHello方法
Chinese.prototype.sayHello = function()
{
alert("中国人问好,名字:"+ this.name +",年龄:"+ this.age);
}
// 测试
var c = new Chinese("张三", 20);
c.sayHello();
首先封装好子类的属性和方法,然后创建一个父类实例附给子类的prototype属性,这样子类就有了父类的属性和方法,即实现了继承
3)javaScript模拟的继承还要以下问题:
a 不能定义保护的方法和属性。
b 不能继承父类的静态方法。
5.多态的实现
1)重载
由于JavaScript的弱类型性,JavaScript在定义函数时,不需要指定函数参数的类型和个数,这种特性为重载的实现提供了便利。如:
function say(param)
{
// 通过typeof函数,判定不同类型的参数。
if (typeof(param)=="string")
alert("string");
else if (typeof(param)=="number")
alert("number");
else
alert("others");
}
JavaScript中另外一种比较常见的重载方式是通过函数的arguments对象来实现,这种方式已在前面讲过,不再赘述.
2)JavaScript中覆盖的实现,只需在子类中定义一个与父类同名的方法即可。
6.静态类的实现
静态类,是一种不能被实例化,并且只包含有静态成员的类,可以通过实例化匿名函数来实现静态类new function(0.
UtilTool = new function() // 关键在于这个new
{
var me = this;
// 增加一个静态方法
me.add = function(a, b)
{
return a+b;
}
return me;
}
// 测试
var sum = UtilTool.add(10, 100);
alert(sum);
UtilTool其实是一个对象,只是这个对象属于匿名类,该类在创建完UtilTool这个对象后,就不能再被使用了。而UtilTool是一个对象,不是一个 function,所以不能作为一个类被实例化,因此,它就相当于一个静态类。