基于ECMA 的JavaScript 的面向对象程序设计

   函数 父类() 
    ... {
       // 私有 字段
       定义 x = "我是[父类]的字段 x。";
       // 私有 方法
       函数 方法1() ...{
           println(x);
           println("我是一个[父类]方法1。");
       }
       
       // 公开字段
      自身.x = "我是一个[父类]object 字段 x.";
      // 公开 方法
      自身.方法1 = 函数() ...{
          println(x);
          println(自身.x);
          方法1();
      }
  }
  父类.prototype.方法  =  函数 () 
   ... {
      println("我是一个[父类] prototype方法 ");
  }
  父类.静态方法  =  函数 ()  ... {
      println("我是一个[父类]静态方法!");
  }
   
   
  函数 子类() 
   ... {
      // 私有 字段
      定义 x = "我是一个[子类]字段x!";
      // 私有 方法
      函数 方法2() ...{
          println(x);
          println("我是一个[子类]方法2!");
      }
      // 公开字段
      自身.x = "我是一个[子类]object字段 x";
      // 公开 方法
      自身.方法2 = 函数() ...{
          println(x);
          println(自身.x);
          方法2();
      }
      自身.方法3 = 函数() ...{
          方法1();
      }
  }
   
   //  继承
  子类.prototype  =  创建 父类();
  子类.prototype.构造器  =  子类;
   
   
   
   //  测试
  定义 临时对象  =  创建 子类();
   
  println( " 临时对象为父类： "   +  (临时对象 实例 父类));     //  true
  println( " 临时对象为子类： "   +  (临时对象 实例 子类));        //  true
   
  println( " 调用临时对象构造器... " );
  println(临时对象.构造器);   //  函数 子类() {...}
   
   println( " 调用临时对象.方法1... " );
  临时对象.方法1();     //  我是一个 父类 字段!
                   //  我是一个 子类 object 字段!
                   //  我是一个 父类 字段!
                   //  我是一个 父类 方法!
   println( " 调用临时对象.方法2... " );
  临时对象.方法2();     //  我是一个 子类 字段!
                   //  我是一个 子类 object 字段!
                   //  我是一个 子类 字段!
                   //  我是一个 子类 方法!
   println( " 调用临时对象.方法... " );
  临时对象.方法();      //  我是一个 父类 prototype 方法!
   
    // ~ println(" 调用临时对象.方法3...");
   // ~ 临时对象.方法3();                //  Error!!!
    // ~ println(" 调用子类.静态方法()...");
   // ~ 子类.静态方法();    //  Error!!!
  
  
   // ~ 上面这个例子很好的反映出了如何利用原型继承法来实现继承。

// ~ 利用原型继承的关键有两步操作：

// ~ 首先创建一个父类的实例化对象，然后将该对象赋给子类的 prototype 属性。

// ~ 这样，父类中的所有公有实例成员都会被子类继承。并且用 instanceof 运算符判断时，子类的实例化对象既属于子类，也属于父类。

// ~ 然后将子类本身赋值给它的 prototype 的 constructor 属性。（注意：这里赋值的时候是没有 () 的！）

// ~ 这一步是为了保证在查看子类的实例化对象的 constructor 属性时，看到的是子类的定义，而不是其父类的定义。




// ~ 你可能会说，这样子覆盖是不错，但 java 中，覆盖的方法里面可以调用被覆盖的方法（父类的方法），在这里怎么实现呢？也很容易，而且比 java 中还要灵活，java 中限制，你只能在覆盖被覆盖方法的方法中才能使用 super 来调用次被覆盖的方法。我们不但可以实现这点，而且还可以让子类中所有的方法中都可以调用父类中被覆盖的方法。看下面的例子：
   function parentClass()  ... {
       this.method = function() ...{
           println("parentClass method");
       }
   }
   function subClass()  ... {
       var method = this.method;
       this.method = function() ...{
           method.call(this);//method();
          println("subClass method");
      }
  }
  subClass.prototype  =   new  parentClass();
  subClass.prototype.constructor  =  subClass;
   
  var o  =   new  subClass();
  o.method();
  
   // ~ 你会发现，原来这么简单，只要在定义覆盖方法前，定义一个私有变量，然后把父类中定义的将要被覆盖的方法赋给它，然后我们就可以在后面继续调用它了，而且这个是这个方法是私有的，对于子类的对象是不可见的。这样跟其它高级语言实现的覆盖就一致了。


以上例子使用了 中文 代替鸟语的关键字，是为了清楚易读。如果要不加修改使用上面的例子，请联系作者
索取 能解释 中英文双关键字的 javascript  解释器