一：Ext下类函数定义
extcore通过：Ext.extend方法来创建类（构造函数），这个类以下用sb代替。
这个类函数默认会有这些属性（类属性）。
superclass：父类，也就是第一个或第二个参数的prototype属性对象。（具体根据传入的参数类型决定）
superclass(): 父类，(sb.propertype下) 这是一个函数，该函数返回父类的propertype对象
supr():同上
constructor()：构造函数，（sb函数的propertype对象下）实际上引用的就是sb函数自己。
override(o)：重写方法，（sb函数下），调用的是 Ext.override(sb, o);也就是将o中的属性复制到sb的propertype下。
override(o)：重写方法，（sb.propertype下）也就是将o的属性复制到sb的propertype下。
extend(o):(sb函数下),该函数调用的是Ext.extend(sb.o);

Ext.extend(sb, sp, overrides)方法有三个参数，这三个参数有一定的类型要求：
sb 一般情况下是一个类函数。
sp：有两种情况：一种是类函数，另一种是：一个Object对象。
overrides：Object对象，通过Ext.override(sb, overrides);方法覆盖类对象的属性。

通过代码分析，可以看出Ext.extend方法有两个应用：
第一：
因为js没有重构语法，所以我们没办法定义js方法的重构，而上边这个extend方法，可以说是一种重构的实现。因为，我们通过代码的分析，我们可以总结出extend方法的参数传

递方式。(用面向对象语言来表示的话，如下结构)
1:extend(Calss sb,Object sp);
2:extend(Calss sb,Class sp);
3:extend(Calss sb,Class sp,Object overrides);
第一种方式目的是定义一个类函数，这个类函数的父类为sb类函数，属性方法的定义在sp对象中完成。
比如： var Student = Ext.extend(Person,{
    constructor:function(old){
  this.age=old;
 },
   name:'sam'}
})
其实通过
  if(Ext.isObject(sp)){
                    overrides = sp;
                    sp = sb;
                    sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
                }

我们可以看出Ext.extend

只有在sp.constructor==Object.prototype.constructor的时候，才创建并返回一个函数，该函数就一句话，

就是调用sb（即父类构造函数）

如果sp.constructor==Object.prototype.constructor

那么sp应该是这样，是一个对象直接量，或者new Object方式创建的对象，且它们都没有显示定义

constructor方法。

以下这几种情况都不会有sp.constructor==Object.prototype.constructor。

1：var obj = new Object(); 

obj.constructor=function(){...};

Ext.extend(sb,obj) //extend 返回的类就是constructor函数

2: var obj = {

constructor:function(){...}

};

Ext.extend(sb,obj) //extend 返回的类就是constructor函数

3: var obj = new function(){...}();  

Ext.extend(sb,obj) //extend返回的类就是这个匿名函数

4: var obj = new function(){

this.constructor=function(){...} 

}();

Ext.extend(sb,obj) //extend 返回的类就是constructor函数。

总结 ：其实很简单,Ext.extend这么做的目的是要说，定义一个类，构造函数就是constructor方法，如果没显示定义这个方法，那么类就使用父类函数作为新类的构造函数。

var A=function(){
   alert("this is a");
}
var B=function(){
   alert("this is b");
}

var SubA = Ext.extend(A,new B());
var subA = new SubA();//这里就会弹出 this is  a 的提示。
第二种方式：修改现有类的类结构
2:extend(Calss sb,Class sp);
这个方法的目的其实之一种包装，是将sb继承于sp下，不管sb是不是ext框架下的类，在这个方法执行后sb就成了ext框架
下的类结构了
3:extend(Calss sb,Class sp,Object overrides);
除了有第二种方法的功能外，还额外的给sb添加或覆盖新的方法或属性
Ext.extend(Person,DongWu);
Ext.extend(Person,DongWu，{sex:'man'});

sam.chuan.yang 2010-06-29 07:07 发表评论

]]>

　　例：
    function Person(){　}；
　　Person.prototype.name = 'sam';
    Person.prototype.sex = "男"；
    var person = new Person();
    alert(person.name) //值为sam；

　　注意：用构造函数体内定义的属性(如b: this.xxprop1=xxvalue1;) 与在函数的prototype
对象里添加属性的方式有什么区别?
    主要区别在于:构造函数体内定义的属性每次new一个新的对象时，都会在内存中创建这些属性
的副本，而prototype里添加的属性则不会，它们在内存中始终只有一份．不会因为对象的创建，
存在对分属性的内存空间．但是他们的访问方式都是一样的，都是通过对象名点属性名的方式
（person.name）．
   d: 通过对象直接量的方式添加对象属性．格式：　var objectName={xxprop1:xxvalue,
     xxprop2:xxvalue2};
   我们知道javascript创建一个对象，有三种方式：
　　　　第一种：通过Object函数创建．如：var person = new Object();
    然后通过上面a的方式加入属性值如: person.name = 'sam';
        第二种: 通过定义构造函数来创建.如上b方式.如:　person = new Person();
        第三种方式：通过对象直接量创建. 比如:
　　　　var person = {name:'sam',sex:'man',age:18};
    即：大括号内写入 属性 冒号 值　，即可．