JavaScript面向对象编程

  翻看了现在比较流行的几个JS脚本框架的底层代码,虽然是走马观花,但也受益良多,感叹先人们的伟大。感叹是为了缓解严肃的气氛并引出话题,“Javascript面向对象编程”,接下来,围绕面向对象的几大关键字:封装,继承,多态,展开。

  封装:javascript中创建对象的模式中,个人认为通过闭包才算的上是真正意义上的封装,所以首先我们先来简单介绍一下闭包,看下面这个例子:

程序代码 程序代码
<script type="text/javascript">
  function myInfo(){
    var name ="GRUB",age =100;
    var myInfo = "my name is" + name + "i am" + age +"years old";
    function showInfo(){
      alert(myInfo);
    }
    return showInfo;
  }
  var grubx = myInfo();
  grubx();
</script>

  是不是很眼熟呢?没错了,这其实就是一个简单的闭包应用了。简单解释一下:上面的函数myInfo中定义的变量,在它的内嵌函数showInfo中是可访问的(这个很好理解),但是当我们把这个内嵌函数的返回引用赋值给一个变量oldFish,这个时候函数showInfo是在myInfo函数体外被调用,但是同样可以访问到定义在函数体内的变量。

  总结一下闭包的原理吧:函数是运行在定义他们的作用域中而不是调用他们的作用域中。其实返回一个内嵌函数也是创建闭包最常用的一种方法!

  如果觉得上面的解释太抽象的话,那么我们一起重塑上面的函数,看看这样是否层次鲜明一些:

程序代码 程序代码
<script type="text/javascript">
  var grubx = function(name,age){
    var name = name,age = age;
    var myInfo = "my name is" + name + "i am" + age +"years old";
    return{
      showInfo:function(){
        alert(myInfo);  
      }    
    }
  }
  grubx("GRUB",100).showInfo();
</script>

  上例中的编码风格公私分明,一目了然。通过闭包,我们可以很方便的把一些不希望被外部直接访问到的东西隐藏起来,写的挺累,饶了一圈终于转回来了,封装嘛,不就是把不希望被别人看到的东西隐藏起来嘛!当然Javascript中还有”潜规则”式的封装形态,是开发者之间都达成共识的一种伪封装模式,就是人为的在私有变量和方法前加下划线“_”,标识警戒讯号!可能有人会问,哪种模式好呢?这个怎么说呢?两种方式都有优缺点,结合着用呗!总之一个原则,一定一定不能直接被外部对象访问的东西,就用闭包封装吧。”一定一定”四个字很深奥,不断实践中才能体会真谛!

  继承:提到这个的时候,要顺便再补充一句:上例封装中的一个缺点,不利于子类的派生,所以闭包有风险,封装需谨慎!直观起见,下面例子中创建对象的方式,采用”门户大开型”模式。

  在javascript中继承一般分为三种方式:”类式继承”,”原型继承”,”掺元类”。下面简单的介绍一下三类继承方式的原理。

  A.类式继承:这个是现在主流框架中常用的继承方式,看下例:

程序代码 程序代码
<script type="text/javascript">
  var Name = function(name){
    this.name = name;
  };
  Name.prototype.getName = function(){
    alert(this.name);
  };
  var grub = function(name,age){
    Name.call(this,name);
    this.age = age;
  };
  grub.prototype = new Name();
  grub.prototype.constructor = Fish;
  grub.prototype.showInfo = function(){
   alert(this.age);
  }
  var grubx = new grub("GRUB",100);
  grubx.getName();
</script>

  上述子类grubx中并没定义getName方法,但是子类grub的实例对象grubx依然调用到了该方法,这是因为子类grub继承了超类Name中定义的getName方法。解释一下,这里子类grub的prototype指到了超类的一个实例,在子类grub中虽然没有申明getName方法,但是根据原型链原理,会向prototype指向的上一级对象中去查找是否有该方法,如果没找到该方法,会一直搜索到最初的原型对象。这其实也就是继承的原理了。这里特别说明一下,grub.prototype.constructor = grub;这句,由于默认子类的prototype应该是指向本身的,但是之前把prototype指向到了超类的实例对象,所以在这里要把它设置回来。当然这里可以把相关代码通过一个函数来组织起来,起到伪装extend的作用。

  B.原型继承,从内存性能上看优于类式继承。

程序代码 程序代码
<script type="text/javascript">
  function clone(object){
    var X = function(){};
    X.prototype = object;
    return new F();
  };
  var Name = {
    name:"who's name",
    showInfo:function(){
      alert(this.name);
    }
  };
  var grub = clone(Name);
  //grub.name = "GRUB";
  grub.showInfo();
</script>

  很明显,原型继承核心就是这个clone函数,同样是原型链的原理,不同的是它直接克隆超类,这样的话子类就继承了超类的所有属性和方法.特别说一下,这类继承并不需要创建构造函数,只需要创建一个对象字变量,定义相应的属性和方法,然后在子类中只需要通过圆点”.”符号来引用属性和方法就可以了。

  C.掺元类:把一些常用通用性比较大的方法统一封装在一个函数中,然后通过下面这个函数分派给要用到这些方法的类.还可以针对不同的类,选择性的传递需要的方法。

程序代码 程序代码
<script type="text/javascript">
  function agument(receveClass,giveClass){
    if(arguments[2]){
      var len = arguments.length;
      for(i=2;i<len;i++){
        receveClass.prototype[arguments[i]] = giveClass.prototype[arguments[i]];
      }
    }
    else{
      for(method in giveClass.prototype){
        if(!receveClass.prototype[method]){
          receveClass.prototype[method] = giveClass.prototype[method];
        }
      }
    }
  };
  var Name = function(){};
  Name.prototype ={
    sayLike:function(){
      alert("i like grub");
    },
    sayLove:function(){
      alert("i love grub");
    }
  }
  var grub = function(){};
  var grubx = new grub();
  agument(grub,Name,"sayLove");
  grubx.sayLove();
  grubx.sayLike();
</script>

  多态:个人觉得这个比较抽象,很难言传,所以下面就从重载和覆盖两个方面来简单阐述一下。

  重载:上面这个例子中agument函数初始带了两个参数,但是在后面的调用中,agument(grub,Name,”sayLove”)同样可以带入任意多个参数,Javascript的重载,是在函数中由用户自己通过操作arguments这个属性来实现的。

  覆盖:这个很简单,就是子类中定义的方法如果与从超类中继承过来的的方法同名,就覆盖这个方法。

[本日志由 GRUB 于 2009-04-21 02:49 PM 编辑]
文章来自: 本站原创
引用通告: 查看所有引用 | 我要引用此文章
Tags: JavaScript 面向对象 封装 继承 多态 展开
评论: 0 | 引用: 0
发表评论
你没有权限发表评论!