//语法甘露：
        
var object =        
//定义小写的object基本类，用于实现最基础的方法等
        {
                isA:
function(aType)    
//一个判断类与类之间以及对象与类之间关系的基础方法
                {
                        
var self =
this;
                        
while(self)
                        {
                                
if (self == aType)
                                    
return
true;
                                self = self.Type;
                        };
                        
return
false;
                }
        };
        
        
function Class(aBaseClass, aClassDefine)        
//创建类的函数，用于声明类及继承关系
        {
                
function class_()    
//创建类的临时函数壳
                {
                        
this.Type = aBaseClass;        
//我们给每一个类约定一个Type属性，引用其继承的类
                        
for(
var member
in aClassDefine)
                                
this[member] = aClassDefine[member];        
//复制类的全部定义到当前创建的类
                };
                class_.prototype = aBaseClass;
                
return
new class_();
        };
        
        
function New(aClass, aParams)    
//创建对象的函数，用于任意类的对象创建
        {
                
function new_()        
//创建对象的临时函数壳
                {
                        
this.Type = aClass;        
//我们也给每一个对象约定一个Type属性，据此可以访问到对象所属的类
                        
if (aClass.Create)
                            aClass.Create.apply(
this, aParams);    
//我们约定所有类的构造函数都叫Create，这和DELPHI比较相似
                };
                new_.prototype = aClass;
                
return
new new_();
        };
        
//语法甘露的应用效果：        
        
var Person = Class(object,            
//派生至object基本类
        {
                Create:
function(name, age)
                {
                        
this.name = name;
                        
this.age = age;
                },
                SayHello:
function()
                {
                        alert(
"Hello, I'm " +
this.name +
", " +
this.age +
" years old.");
                }
        });
        
        
var Employee = Class(Person,        
//派生至Person类，是不是和一般对象语言很相似？
        {
                Create:
function(name, age, salary)
                {
                        Person.Create.call(
this, name, age);    
//调用基类的构造函数
                        
this.salary = salary;
                },
                ShowMeTheMoney:
function()
                {
                        alert(
this.name +
" $" +
this.salary);
                }
        });
        
var BillGates = New(Person, [
"Bill Gates", 53]);
        
var SteveJobs = New(Employee, [
"Steve Jobs", 53, 1234]);
        BillGates.SayHello();
        SteveJobs.SayHello();
        SteveJobs.ShowMeTheMoney();
        
        
var LittleBill = New(BillGates.Type, [
"Little Bill", 6]);    
//根据BillGate的类型创建LittleBill
        LittleBill.SayHello();
        
        alert(BillGates.isA(Person));            
//true
        alert(BillGates.isA(Employee));        
//false
        alert(SteveJobs.isA(Person));            
//true
        alert(Person.isA(Employee));                
//false
        alert(Employee.isA(Person));                
//true