extjs3.3.1中继承实现代码的抽取和调用

今天看了一下extjs中继承部分的代码，并把它抽取出来，加了些注释，并写了调用方法。具体如下：

<script>

Ext = function() { };

Ext.isIE = false;//这里就不去管是不是IE了，不是问题的重点，我是在firefox下调试处理的。

Ext.apply = function(o, c, defaults){

    // no "this" reference for friendly out of scope calls

    if(defaults){

        Ext.apply(o, defaults);

    }

    //extjs在这里做了子类方法对父类方法的覆盖处理

    if(o && c && typeof c == 'object'){

        for(var p in c){

            o[p] = c[p];

        }

    }

    return o;

};

Ext.override=function(origclass, overrides){

            if(overrides){

                var p = origclass.prototype;

                Ext.apply(p, overrides);

                if(Ext.isIE && overrides.hasOwnProperty('toString')){

                    p.toString = overrides.toString;

                }

            }

        };

Ext.extend=function(){

            // inline overrides

            var io = function(o){

                for(var m in o){

                    this[m] = o[m];

                }

            };

            var oc = Object.prototype.constructor;

            return function(sb, sp, overrides){

               //只有两个参数的情况下，将参数转成三个参数的形式统一处理

                if(typeof sp == 'object'){

                    overrides = sp;

                    sp = sb;

                    //如果只有两个参数，将第二个参数的constructor作为subclass

                    //这也出现了另人迷惑的问题：传两个参数时，生成类实例时，sp的constructor会执行，

                    //而传三个参数时，overrides的constructor不会执行,这也是无奈之举，javascript没有java的overload特性

                    //extjs的代码注释也有说明：传三个参数的形式下，第一个参数就是subclass的constructor，第二个是superclass，第三个参数用于copied into the subclass's prototype

                    sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};

                }

                //造了一个空构造方法的函数，用来接收superclass的prototype

                var F = function(){},

                    sbp,

                    spp = sp.prototype;

                F.prototype = spp;

                //原型继承的关键代码在这里，将subclass的原型指向一个F的实例,用F的实例比直接用superclass的实例好，

                //原因在于这样处理创建子类时就不用执行superclass的构造函数，而是执行一个空构造函数F

                sbp = sb.prototype = new F();

                //修正subclass的prototype的constructor指向

                sbp.constructor=sb;

                //其实subclass的superclass为superclass的prototype

                sb.superclass=spp;

                //父类在创建完后，其constructor都不会是Object的constructor,为什么要修正父类的constructor，这个搞不明白

                if(spp.constructor == oc){

                    spp.constructor=sp;

                }

                sb.override = function(o){

                    Ext.override(sb, o);

                };

                sbp.superclass = sbp.supr = (function(){

                    return spp;

                });

                sbp.override = io;

                //这里把overrides的方法拷贝给子类的prototype

                Ext.override(sb, overrides);

                //给子类添加extend方法，调用时只传overrides参数就可以生成子类的子类

                sb.extend = function(o){return Ext.extend(sb, o);};

                return sb;

            }(); //返回的是匿名方法的执行结果，也就是sb

        };

//第一种创建方法,传三个参数创建子类

 var Person=function(name){

  this.name=name;

}

 Person =Ext.extend(Person,Object,{

            getName: function(prefix) {

                return this.name;

            }});

var p=new Person("person");

console.log("name:"+p.getName());

//第二种创建方法，传两个参数创建子类

var Employee =Ext.extend(Person,{

            constructor: function(name, employeeID) {

          //  调用父类的方法,这个是参照ext源码写出来的调用方法，感觉不是很爽

         Employee.superclass.constructor.apply(this,[name]);

                this.employeeID = employeeID;

                console.log(employeeID);

            },

            getEmployeeID: function() {

                return this.employeeID;

            }

        });

var ee=new Employee("employee",11);

console.log("name:"+ee.getName()+",id:"+ee.getEmployeeID());

//第三种创建方法，调父类的extend方法创建子类

var Employer =Person.extend({

      constructor: function(name, employerID) {

                Employer.superclass.constructor.apply(this,[name]);

                this.employerID = employerID;

                console.log(employerID);

            },

            getEmployerID: function() {

                return this.employerID;

            }

        });

var er=new Employer("employer",12);

console.log("name:"+er.getName()+",id:"+er.getEmployerID());

</script> 

javascript的继承实现可以参考：

1.《悟透javascript》

2.帖子： [原创]JavaScript继承详解

3.还有一本书《Object-Oriented Javascript》(我是还没来得及看，有空再看）