JavaScript和java的面向对象1

 
 
 这里的JavaScript,主要是指ECMAScript。Java大致基于1.5版本。这篇文章比较用JavaScript来实现OO与用java来实现的差异性。
 
 第一节 面向对象的能力
 
  判定一种语言是否具有支持OO，看要它是否具备OO的四个基本特性：
  1. 封装
  2.  聚合
  3. 继承
  4. 多态
  ECMAScript是支持这些要求的.java当然也支持。因此可以认为ECMAScript支持OO,java亦然。
  
 
  ECMAScript 对于对象的理解为“属性的无序集合，每个属性存放一个原始值、对象或函数”，可以认为在ECMAScript中的对象完全
  由多个属性构成，如果这个属性存放的值是函数，就认为它是对象方法。而且在ECMAScript中对象没有显式的“类”定义,对象的定义实际上就是对象自身。
  ECMAScript只有一种访问作用域public. ECMAScript不支持静态作用
  
  Java的对象是具有类定义，类有方法，属性，还有静态，和访问作用域（public ,private, protected)。java支持静态作用域
  
  早绑定与晚绑定
  所谓绑定，是把对象的接口和对象实例结合在一起的方法。
  早绑定，是在实例化对象之前定义它的特性与方法，编译器或解释程序就能提前转为机器代码。java是属于早绑定
  晚绑定，是编译器和解释程序在运行前，不知道对象的类型。ECMAScript的所有变量采用晚绑定。
  
 第二节 定义类或对象
  ECMAScript定义类或对象的有几种：
  工厂方法  提供能创建并返回特定类型对象的工厂函数
       function createCar(sColor, iDoors, iMpg){
        var oTempCar = new Object;
        oTempCar.color = sColor;
        oTempCar.doors = iDoors;
        oTempCar.mpg = iMpg;
        oTempCar.showColor = function (){
         alert(this.color);
        };
        return oTempCar;
       }
       varCar1 = createCar("red", 4, 23);
  
  构造函数方式 第一步选择类名，即构造函数的名字，根据惯例这个构造函数的首字母大写。
       function Car(sColor, iDoors, iMpg){
        
        this.color = sColor;
        this.doors = iDoors;
        this.mpg = iMpg;
        this.showColor = function (){
         alert(this.color);
        };
        
       }
       var oCar1 = new Car("red", 4, 23);
  
  原型方式 该方式利用对象的prototyppe属性
       function Car(){
       }
       Car.prototype.color = "red";
       Car.prototype.doors = 4;
       Car.prototype.mpg = 23;
       Car.prototype.showColor = function (){
         alert(this.color);
       };
             
       var oCar1 = new Car();
   
  混合构造函数/原型方式 利用构造函数方式来定义对象的所有非函数属性，利用原型方式来定义
        对象的函数属性(这种方式是开发者采取的主要方式)
       function Car(sColor, iDoors, iMpg){
        
        this.color = sColor;
        this.doors = iDoors;
        this.mpg = iMpg;
        
        
       }
       Car.prototype.showColor = function (){
         alert(this.color);
       };
       var oCar1 = new Car("red", 4, 23);
  动态原型方式 对于对象的函数和属性进行完全的封装到构造函数中
       
       function Car(sColor, iDoors, iMpg){
        
        this.color = sColor;
        this.doors = iDoors;
        this.mpg = iMpg;
        
        if(typeof Car._initialized=="undefined"){
         Car.prototype.showColor = function (){
          alert(this.color);
         };
         Car._initialized = true;
        }
       }
       
       var oCar1 = new Car("red", 4, 23);
  混合工厂方式 这种方式是不能应用前一种方式的变通方法。通过提供假构造函数，返回另一种对象的新实例。
       function Car(sColor, iDoors, iMpg){
        var oTempCar = new Object;
        oTempCar.color = sColor;
        oTempCar.doors = iDoors;
        oTempCar.mpg = iMpg;
        oTempCar.showColor = function (){
         alert(this.color);
        };
        return oTempCar;
       }
       varCar1 = new Car("red", 4, 23);
     
  
  采用那种方式
   
   目前广泛使用的是构造函数/原型方式。动态原型方法也很流行，功能上与构造函数/原型等价
   
  Java定义类/对象的方式
  
    Java采用严格的类声明方式
    Class Car {
     private String color;
    
     public String showColor(){
      ...
     }
    }
  
   还有一种在特殊方式，用在产生interface和abstract类的实例，即匿名类方式。
   
  第三节 修改对象定义
    
   这个功能是ECMAScript具有，而java不具有的能力。
   
   创建新方法
     可以使用Prototype属性为任何已有的类定义新方法。
     
     Number.prototype.toHexString = funtion (){
      return this.toString(16);
     };
 
   重定义已有方法
     同定义新方法一样，也可以重定义已有的方法。函数名只是指向函数的指针，因此可以轻易的使它指向其他函数。
     
     Function.prototype.toString = function (){
      return "Function code hidden";
     };
     function sayHi() {
      alert("hi");
     }
    
     alert(SayHi.toString());
     
  极晚绑定
   这是一种现象，能够在对象实例化后再定义其方法。应该尽量少用。