js面向对象学习

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，所以不能作为一个类被实例化，因此，它就相当于一个静态类。