在javascript中，Object对象是通用类，其他所有内置对象和自定义构造对象都是专用类，即Object对象是超类，其他内置对象和自定义对象都是Object的子类，所有在javascript语言中，所有的对象都继承Object定义的属性和方法
Object.prototype.name='Owen';//超类的原型属性
var d=Date.prototype;
alert(d.name);//Owen，子类继承超类
function Me(){}
var m= Me.prototype;
alert(m.name);//Owen，子类继承超类
例2：把父类的实例传给子类的prototype属性时，破会了原型构造与默认构造器的引用关系，需要进行构造器的修正
Object.prototype.name='Owen2';
function Me(){this.saying=function(){return '父类的方法'}}
function Sub(){}
Sub.prototype=new Me();//此时的Sub.prototype.constructor指向了Me类的引用
Sub.prototype.constructor=Sub;//修正子类的原型对象的构造器指回子类本身
var m=new Sub();
alert(m.name);//Owen
alert(m.saying());//父类的方法
设计元类：
元类就是类的类型，即创建类型的类，元类能够接受 类 作为参数，返回的是类，即元类操作的对象是类，不是具体的数据
function O(){
return function(){
this.x=x;
this.get=function(){
alert(this.x);
}
}
}
var o=new O(1);//实例化元类
var f=new o();//实例化 元类 返回的类
f.get(); //1
例2:javascript核心对象Function就是一个元类
var O=new Function("this.x=1;this.y=2");
var o=new O();//实例化 返回的类
alert(o.x);//1
例3：
function F(x,y){//作为参数的类
this.x=x;
this.y=y;
}
F.prototype.add=function(）{
alert(this.x+this.y);
}
function O(o,x,y){//元类
this.say=function(){ alert('元类')}//元类的本地方法
return function(){
this.say=funciton(){alert('返回类')}
var a=new o(x,y);//实例化参数类
for(var i in a){ this[i]=a[i];}
}
}
var A=new O(F,1,2);//实例化元类，此时A是一个类结构，不能通过A读取元类本地方法say()
var B=new A();//实例化元类的返回类
A.say();//提示编辑错误
B.say();//返回类
B.add();//3
alert(B.x);//1
alert(B.y);//2
注意：当一个类有返回值时，如果类型是值类型，则可以访问类的成员，也可以获取返回值
function F(){
this.x=1;
return 2;
}
var f=new F();
alert (f.x);//1
alert(F());//2
但如果类返回的是引用类型或者是函数时，则类的成员将不可访问，它们将成为闭包结构的私有数据
function F(){
this.x=1;
return function(){ return this.x;}
}
F.prototype.y=function(){alert(3)}
var f=new F();
alert(f.x);//访问本地属性x失败，返回 undefined
alert(F()());//1,调用返回的函数 可以访问本地属性x
alert(f.y());//编辑错误，没有这个成员