js的抽象方法

一.JavaScript中类的封装
Javascript不是一种面向对向的语言, 没有提供对类的支持, 因此我们不能像在传统的语言里那样用class来定义类, 但我们可以利用js的闭包封装机制来实现js类, 下面我们以封装一个简单的Shape类来作一个说明.
定义 ShapeBase“类”
1.法则一[this式]
function ShapeBase(){
this.show = function(){
alert(“ShapeBase show”);
};
this.init = function(){
alert(“ShapeBase init”);
};
}
注：这里用到了this来声明，而不是var，后者是用来定义私有方法的。

   2.法则二[prototype式]
   ShapeBase.prototype.show=function(){ 
          alert("ShapeBase show"); 
   } 
   ShapeBase.prototype.init=function(){ 
          alert("ShapeBase init"); 
   }
    或者
    ShapeBase.prototype={
              show:function(){
                      alert("ShapeBase show");
               }
              init:function(){
                       alert("ShapeBase init");
               }       
    }

    同构造java一样，我们写一个主函数调用测试下。如下
     funciton test(){
            var s = new ShapeBase();
            s.init();
            s.show();
     }

    可以看到我们在构造JS类上有两中方式，在调用中我们发现其方式与java类几乎一样，new一个类对象，通过引用发送消息的形式调用具体类的方法。差别仅在于这个时候生成的类对象的类型这里还是记为var。

二.JS抽象类和继承
类的封装我们已经实现了，而面向对象其他的一些优良特性我们也可以通过JS本身的特性来实现。这种化归思想本身就是一种技巧。
我们可以利用JavaScript语言本身的性质来实现其抽象类，也可以通过将父类prototype中的成员方法复制到子类的prototype中来实现其继承机制。
即将面向对象编程中的继承概念转化为javascript语言中的函数属性复制。
1.JS中的实例prototype方法
可实例化的prototype方法
Object.prototype.extend = function(object) {
return Object.extend.apply(this, [this, object]);
}
2.JS中的虚方法
在传统语言中虚方法要先定义, 而包含虚方法的类就是抽象类,抽象类不能被实例化,但在JavaScript中，虚方法是被看作该类中未定义的方法，但已经通过this指针使用了. 所以JS中的虚方法不需经过声明而直接使用, 并且类也可以被实例化.
静态方法：
Object.extend = function(destination, source){
for(property in source){
destination[property] = source[property];
}
return destination;
}
3.1继承[实例方法prototype]
以object为例。先定义object的extend方法, 一个为静态方法，一个为实例方法, 这两个方法用于通过prototype来实现的继承机制。
实现继承类Rect
function Rect(){
//
}
// 实现继承
Rect.prototype = ShapeBase.prototype;
//扩充新方法
Rect.prototype.add = function(){
alert(“Rect add”);
}
注：这里的继承有一种区别于一般面向对象的继承特性。可能是由于prototype赋值只是简单的改变指向地址，会导致一种现象，即如果重写了“子类”的方法，则“父类”的方法也随之改变。这种权利转移的确让人惊讶。
测试例子如下：
如果在子类重写show方法
Rect.prototype.show = function(){
alert(“Rect show”);
}

   则执行结果如下：
   function test(){
         var s = new ShapeBase();
         //结果显示：Rect show
         s.show(); 

          //结果显示：Rect show
         var r = new Rect();
         //结果显示：Rect add
          r.add();
   }

   3.2继承[静态方法]
   使用object.extend实现继承, 并实现一个oninit虚方法, 修改“父类”ShapeBase如下:
          ShapeBase.prototype = {
                    show:function(){
                               alert("ShapeBase show");
                     }
                     initialize:function(){
                                this.oninit();
                     }
            }
            子类Rect
             Rect.prototype = (new ShapeBase).extend({
                         //添加新方法
                         add:function(){
                                  alert("Rect add");
                          },
                         // 重写show方法而不改变父类方法
                         show:function(){
                                  alert("Rect show");
                         },
                         //实现虚方法
                         oninit:function(){
                                 alert("Rect oninit");
                          }
             })

             测试类如下：
             function test(src){
                     var s = ShapeBase();
                     //显示ShapeBase show[来自父类]
                     s.show();
                     var r = new Rect();
                     //显示Rect show [来自子类]
                     r.show();
                     //显示Rect add [来自子类扩充方法]
                     r.add();
                      //显示Rect oninit [来自实现的oninit方法]
                     r.initialize();
             }

三.特定对象创建类
特定对象实现属性复制
function extend(des, src){
if(!des){
des = {};
}
if(src){
for(var i in src){
des[i] = src [i];
}
}

        return des;

   }

   //全局变量
   var CC = {}；
   //设置create用于创建类
   CC.create = function(superclass,constructor){
           var clazz = (function(){
                  this.initialize.apply(this,arguments);
           });
                   //如果无参数，则直接返回类
                   if(arguments.length == 0){
                             return clazz;
                   }
                   //如果父类此时constructor应该成为一个纯对象，直接复制属性返回
                   if(!superclass){
                             extend(clazz.prototype,constructor);
                             return clazz;
                   } 

                   var absObj = clazz.prototype,
                         sprPropty = superclass.prototype;
                   if(sprProty){
                         //用于访问父类方法
                         clazz.superclass  = prototype;
                         extend(absObj ,sprPropty);
                         //调用属性构造函数创建属性。实现的关键
                         extend(absObj, constructor(sprPropty));
                     //子类实例直接通过obj.superclass访问父类属性。
                    //如果不想造成过多引用，可以把这句注释掉。多数时候也没有必要
                         absObj.superclass = sprPropty;
                         clazz.constructor = constructor;
                    }
                    return clazz;
   }

   //创建一个动物类
   var Animal = CC.create(null ,{
             //属性
             footprint:‘-------------------=’,
             //类初始化方法。当用new生成一个类时该方法自动被调用。参见上述                  //定义
             initialize:function(options){
                     extend(this,options);
                     alert("Animal initialize method is called.");
             }
             eat:function(){
                      alert("Animal eat method is called");
             }
             move:function(){
                      alert("I am moving like this '+ this.footprint+' .");
             }
      });

      //创建一个Duke类
      var Duke = CC.create(Animal,function(superclass){
               //此处可定义类全局静态数据，该类每个实例都共享这些数据。
               //计算实例个数，包括派生类实例
               var static_instance_counter = 0;
               function classUtilityFuncHere(){};
               //返回类具体属性
               return{
                      // 重写初始化方法
                      initialize:function(){
                             alert("initializing Duke class");
                      }
                      //调用父类初始化。比一般其它库要简洁。
                      superclass.initialize.call(this,options);
                      //子类扩充
                      alert("Duke initialize method is called.");
                      //读取或修改类静态属性
                      static_instance_couter++;

               },

               //重写move方法并增加Duke自己的移动方式
               move:function(){
                      this.footprint = this.footprint + "zzzzzzzzzzzzz";
                      superclass.move.call(this);
               },
               //重写eat方法，覆盖父类eat方法
               eat:function(){
                      alert("Duke is eating");
               },
               //子类新增自己的方法,显示当前已经初始化的Duke类实例数量
               say:function(){
                     alert("The number of Duke instance is ' + static_instance_counter' ");
               }
      };

      });

      var DukeChild = CC.create(Duke,function(superclass){
               return{
                       move:function(){
                              this.footprint = this.footprint + "++++++=";
                              superclass.move.call(this);
                       },
                       say:function(){
                              alert("this.msg ||");
                       }
               };

       })

       测试类：
       function test(){
             var animal = new Animal();
             animal.eat()
             animal.move();
             var dukeA = new Duke();
             dukeA.eat();
             dukeA.move();
             dukeA.say();
             var dukeB = new Duke();
             dukeB.eat();
             dukeB.move();
             dukeB.say();
             var dukeC = new DukeChild({msg:'I am a child of duke'});
             duckC.move();
             duckC.say();
       }