面向对象模拟extjs底层继承方式

function extend(sub,sup){
                // 目的： 实现只继承父类的原型对象
                var F = new Function(); // 1. 创建一个空函数     目的：空函数进行中转
                F.prototype = sup.prototype; // 2. 实现空函数的原型对象和超类的原型对象转换
                sub.prototype = new F(); // 3. 原型继承
                sub.prototype.constructor = sub; // 4. 还原子类的构造器
//                5. 保存一下父类的原型对象: 一方面方便解耦（耦合性） 另一方面方便获得父类的原型对象
                sub.superClass = sup.prototype; // 自定义一个子类的静态属性  接收父类的原型对象
                // 6. 判断父类的原型对象的构造器（加保险）
                if(sup.prototype.constructor == Object.prototype.constructor){
                    sup.prototype.constructor = sup; // 手动还原
                }
            }
                    
            // 混合继承 ：  原型继承和借用构造函数继承
            function Person(name, age){
                this.name = name;
                this.age = age;
            }
            
            Person.prototype = {
                constructor: Person,
                sayHello: function(){
                    alert("hello world!")
                }
            }
            
            function Boy(name, age, sex){
                // call 绑定父类的模版函数 实现 借用 构造函数继承 之赋值了父类的模版                
                Boy.superClass.constructor.call(this , name , age); // 超过最大调用堆栈大小了
                
//                Person.call(this , name , age) // 调用了父类的原型对象
                this.sex = sex;
            }
            
            // 原型继承的方式： 即继承了父类的模版    又继承了父类的原型对象
//            Boy.prototype = new Person();

            // 只继承一边父类的原型对象
            extend(Boy , Person)
            
            Boy.prototype.sayHello = function(){
                alert("hi javascript")
            }
            
            var b = new Boy('张三' , 20 , '男')
            alert(b.name)
            alert(b.sex)
            b.sayHello();
            Boy.superClass.sayHello.call(b)
//            console.log(Person)
//            console.log(Boy.superClass.constructor)
            // 混合继承的缺点： 3件事： 继承了父类的2次模版，继承了一次父类的原型对象
            // extend 方法  2件事：继承1次父类的模版  继承一次父类的原型对象