javascript中的面向对象



转自：http://blog.csdn.net/lidatgb/article/details/7694264

对象

        在JavaScript，可以说everything is object，那么什么是对象？对象就是包含一组变量和函数的集合。在其它面向对象语言中对象是由类的实例化而来，JavaScript是基于原型的面向对象语言，没有类的概念，对象派生自现有对象的副本。JavaScript中对象可以分为两类：Function和Object。

创建

        对象     

        为了提高效率，JavaScript自带内置对象，例如：Object、Function、Array等，所有内置对象都可以通过new来创建。Function对象分为两类：实例和构造函数。例如alert('my name is X')是Function的实例；而作为构造函数的Function，必须通过new来实例化。创建的对象的语法分为以下几种：

[javascript] view plaincopyprint?

1. var obj= new Object();var obj={};(Array等类似)  
2. var myFunction=new Function(){//代码};function myFunction(){//代码}  

        var obj= new Object();var obj={};(Array等类似)
        var myFunction=new Function(){//代码};function myFunction(){//代码}

        需要注意的是，第一种Function声明必须在使用之前，而第二种可以在使用之后。

        构造函数

        Function是构造函数的起点，创建构造函数与上述创建对象Function类似

[javascript] view plaincopyprint?

1. var myFunction=new Function('a',/*代码*/)  
2. function myFunction(a){  
3.         /*代码*/  
4. }  

var myFunction=new Function('a',/*代码*/)
function myFunction(a){
        /*代码*/
}

但是由于第一种有性能问题推荐使用第二种；Function对象的特点是：它的实例也能作为构造函数 。

        静态成员

        如下代码：

[javascript] view plaincopyprint?

1. var myObj= new Object();  
2. //添加name属性  
3. myObj.name='LD';  
4. //添加alertName方法  
5. myObj.alertName=function(){  
6.         alert(this.name);  
7. }  
8. //执行alertName  
9. myObj.alertName();  

var myObj= new Object();
//添加name属性
myObj.name='LD';
//添加alertName方法
myObj.alertName=function(){
        alert(this.name);
}
//执行alertName
myObj.alertName();

        name和alertName仅仅存在于myObj实例中，不存在于构造函数。这个还好理解，但是对于既可以是构造函数也可以是实例的Function来说就不那么容易理解了，如下： [javascript] view plaincopyprint?

1. var myConstructor=new function(){  
2. //添加静态属性  
3.         myConstructor.name='LD';  
4. //添加静态方法  
5.         myConstructor.alertName=function(){  
6.          alert(this.nam);  
7. }  
8. }  
9. myConstructor.alertName();  

var myConstructor=new function(){
//添加静态属性
        myConstructor.name='LD';
//添加静态方法
        myConstructor.alertName=function(){
         alert(this.nam);
}
}
myConstructor.alertName();

        代码可以正常运行，因为myConstructor可以是实例，但是name和alertName不会应用到由myConstructor的任何新的实例中。

        公有成员

        能够跟随对象实例化的成员称之为公有成员，成为公有成员需要修改函数的原型，即prototype。公有方法可以随构造函数而被继承下去，方法如下：

[javascript] view plaincopyprint?

1. function myConstructor(){  
2.     
3. }  
4. //添加公有属性  
5. myConstructor.prototype.myName='LD';  
6. //实例化  
7. var myObj=new myConstructor();  
8. alert(myObj.myName);  

function myConstructor(){

}
//添加公有属性
myConstructor.prototype.myName='LD';
//实例化
var myObj=new myConstructor();
alert(myObj.myName);

        由myConstructor实例化的对象可以使用myName，但是myConstructor本身不可以，因为我们把公有成员加到了myConstructor的底层定义中，而非myConstructor实例本身。

        私有成员

        私有成员指的是在构造函数中定义的变量和方法，与其它语言的类中用private定义类似，例如：

[javascript] view plaincopyprint?

1. function myConstructor(){  
2. //添加私有属性  
3.    var myName='Ld'l  
4. //添加私有方法  
5.    var alertName=function(){  
6.        alert('LD');  
7. }  
8. alertName();  

function myConstructor(){
//添加私有属性
   var myName='Ld'l
//添加私有方法
   var alertName=function(){
       alert('LD');
}
alertName();

        特权成员

        特权方法，指的是可以被公开访问，同时其能访问私有成员，在构造函数作用域总使用this定义的方法，类似其它语言中的公有方法，如下：

[javascript] view plaincopyprint?

1. function myConstructor(){  
2. //私有属性  
3.     var sex='male';  
4. // 特权方法  
5.     this.alertSex=function(){  
6.            alert(sex);  
7. }  
8. }  

function myConstructor(){
//私有属性
    var sex='male';
// 特权方法
    this.alertSex=function(){
           alert(sex);
}
}

        对象字面量

        前面我们使用的创建用的都是点，例如myConstructor.name=x;myConstructor.sex=x。我们也可以使用对象字面量来达到相同的目的，例如：

[javascript] view plaincopyprint?

1. function myConstructor(){  
2.   
3. }  
4. //添加公有成员  
5. myConstructor.prototype={  
6.         name:'LD',  
7.         sex:'male',  
8.         method:function(){}  
9. }  

function myConstructor(){

}
//添加公有成员
myConstructor.prototype={
        name:'LD',
        sex:'male',
        method:function(){}
}

        注意，对象字面量中分隔符为逗号，且最后一个属性或方法最后没有逗号，以防解析错误。

this、call和apply

        this,是一个依赖于执行环境的关键字，与创建位置无关，this关键字指向的的是使用包含它的函数的对象，学过C++和其它语言来说，这个不难理解。

       call和applay，这两个的作用强制把方法附加到某个对象，例如：

[javascript] view plaincopyprint?

1. //alertName是已经创建好的函数  
2. //alertName不需要参数时  
3. alertName.call('对象')  
4. //alertName需要参数时  
5. alertName.call('对象',‘参数1’,'参数2')  
6. //alertName使用参数数组时  
7. alertName.applay('对象',‘参数数组arguments')  

//alertName是已经创建好的函数
//alertName不需要参数时
alertName.call('对象')
//alertName需要参数时
alertName.call('对象',‘参数1’,'参数2')
//alertName使用参数数组时
alertName.applay('对象',‘参数数组arguments')

异常处理

        和c#类似，由try、catch组成，如下：

[javascript] view plaincopyprint?

1. function myFunction(){  
2.         window.style.color='red';  
3. }  
4. try{  
5.      myFunction();  
6. }  
7. catch{  
8.      alert('异常信息：'+exception.name + exception.message)  
9. }