Javascript OOP框架YOOP重构实践（下） Wonder

继续重构

提取基类Structure

增加测试

describe("测试AClass", function () {
    it("子类全部实现抽象父类的抽象成员时，不抛出异常", function () {
        var A = YYC.AClass({
            Init: function (t) {
                this.a = t;
                this.b = 2;
            },
            Public: {
                p: function () {
                    return 0;
                }
            },
            Private: {
                _m: 1
            },
            Protected: {
                P_h: function () {
                    return this._m;
                },
                P_k: 3
            },
            Abstract: {
                move: function () { },
                u: 0,
                t: function () { }
            }
        });
        var B = YYC.Class(A, {
            Init: function () {
                this.b = 100;
                this.base(200);
            },
            Public: {
                move: function () {
                    return this.P_h();
                },
                t: function () { },
                u: 20
            }
        });
        var C = YYC.Class(B, {
            Public: {
                move: function () {
                    var baseResult = this.base();

                    return baseResult;
                },
                t: function () { }
            }
        });

        var b = new B();
        var c = new C();

        expect([b.a, b.b]).toEqual([200, 2]);
        expect([b.p(), b.move(), b.u]).toEqual([0, 1, 20]);
        expect(c.move()).toEqual(1);
    });
});

describe("测试Interface", function () {
    it("子类没有全部实现了接口方法和属性，抛出异常", function () {
        var Int = YYC.Interface("A", "B");

        expect(function () {
            YYC.AClass({ Interface: Int }, {
                Public: {
                    B: function () { }
                }
            });
        }).toThrow();

        var Int2 = YYC.Interface(Int, ["C"], ["a"]);

        expect(function () {
            YYC.AClass({ Interface: Int2 }, {
                Public: {
                    A: function () { },
                    B: function () { },
                    C: function () { }
                }
            });
        }).toThrow();
        expect(function () {
            YYC.AClass({ Interface: Int2 }, {
                Public: {
                    B: function () { },
                    C: function () { },
                    a: 1
                }
            });
        }).toThrow();
    });
});

通过重构实践（一）的重构，我发现AClass和Class有很多相似之处，因此启发我采用oo思想来重构，提取出AClass和Class的基类Structure，将两者的共同或相似的代码放到Structure中，然后在Structure中运用模板模式，调用子类实现的方法或属性（如P_class、P_prepareCheck）。

另外进行上面的重构后，可以减少一些方法的形参个数，因为这些形参可以在方法内部通过this来获得了。

如_addStatic重构前：

function _addStatic(_class, prop) {
    var Static = null;
    var k = null;

    Static = prop.Static ? prop.Static : null;
    //静态属性/方法赋值
    for (k in Static) {
        _class[k] = Static[k];
    }
};

重构后（_addStatic移到Structure中，并改名为P_addStatic，表示为保护方法）：

this.P_addStatic = function () {
    var Static = null,
        k = null,
        _class = this.P_class,
        prop = this.prop;

    Static = prop.Static ? prop.Static : null;
    //静态属性/方法赋值
    for (k in Static) {
        _class[k] = Static[k];
    }
};

然后又进行了一些小的重构（如删除密封方法的判断、检查；将AClass、Class中调用成员的职责提取为buildAClass、buildClass；重命名addPublic为prepareAndAddPublic等），重构后结构A2（包括Structure、AClass、Class）为：

(function () {

    function Structure() {
        this.parentClass = null;
        this.interface = null;
        this.prop = null;

        /* 深拷贝
    */
        this.P_extendDeep = function (parent, child) {
            var i = null,
            len = 0,
                  toStr = Object.prototype.toString,
                  sArr = "[object Array]",
                  sOb = "[object Object]",
                  type = "",
           _child = null;

            //数组的话，不获得Array原型上的成员。
            if (toStr.call(parent) === sArr) {
                _child = child || [];

                for (i = 0, len = parent.length; i < len; i++) {
                    type = toStr.call(parent[i]);
                    if (type === sArr || type === sOb) {    //如果为数组或object对象
                        _child[i] = type === sArr ? [] : {};
                        arguments.callee(parent[i], _child[i]);
                    } else {
                        _child[i] = parent[i];
                    }
                }
            }
                //对象的话，要获得原型链上的成员。因为考虑以下情景：
                //类A继承于类B，现在想要拷贝类A的实例a的成员（包括从类B继承来的成员），那么就需要获得原型链上的成员。
            else if (toStr.call(parent) === sOb) {
                _child = child || {};

                for (i in parent) {
                    type = toStr.call(parent[i]);
                    if (type === sArr || type === sOb) {
                        _child[i] = type === sArr ? [] : {};
                        arguments.callee(parent[i], _child[i]);
                    } else {
                        _child[i] = parent[i];
                    }
                }
            }
            else {
                _child = parent;
            }


            return _child;
        };
        //检查子类的公有方法+虚方法+抽象方法是否包含父类的抽象方法/属性 或 接口方法/属性。
        //不用hasOwnProperty判断！否则就检查不到是否包含了父类的抽象方法/属性 或 接口方法/属性。
        this.P_check = function (parentClass) {
            //var parentClass = this.parentClass,
            var interface = this.interface,
                children = this.children;

            if (parentClass) {
                _checkAbstract(parentClass, children);
            }
            else if (interface) {
                _checkInterface(interface, children);
            }
        };
        function _checkAbstract(parentClass, children) {
            var name = "";

            //检查是否实现了抽象方法/属性
            for (name in parentClass.prototype) {
                if (parentClass.prototype.hasOwnProperty(name)) {
                    if (name === "constructor") {
                        continue;
                    }
                    if (name.contain("Abstract_")) {
                        //抽象方法
                        if (typeof parentClass.prototype[name] === "function") {
                            if (_noMethodForAbstract(children, name) && _noMethodForAbstract(parentClass.prototype, name)) {
                                throw new Error("Abstract method '" + name + "' must be overwrited!");
                            }
                        }
                            //抽象属性
                        else {
                            if (_noAttritubeForAbstract(children, name) && _noAttritubeForAbstract(parentClass.prototype, name)) {
                                throw new Error("Abstract attribute '" + name + "' must be overwrited!");
                            }
                        }
                    }
                }
            }
        };
        function _checkInterface(interface, children) {
            var name = "";

            //检查是否实现了接口方法/属性
            for (name in interface.prototype) {
                if (name === "constructor") {
                    continue;
                }
                //接口方法
                if (typeof interface.prototype[name] === "function") {
                    if (_noMethodForInterface(children, name) && _noMethodForInterface(parentClass.prototype, name)) {
                        throw new Error("Interface method '" + name + "' must be overwrited!");
                    }
                }
                    //接口属性
                else {
                    if (_noAttritubeForInterface(children, name) && _noAttritubeForInterface(parentClass.prototype, name)) {
                        throw new Error("Interface attribute '" + name + "' must be overwrited!");
                    }
                }
            }
        };

        function _noMethodForAbstract(_class, name) {
            return _class[name.slice(9)] === undefined || typeof _class[name.slice(9)] !== "function";
        };
        function _noAttritubeForAbstract(_class, name) {
            return _class[name.slice(9)] === undefined || typeof _class[name.slice(9)] === "function";
        };
        function _noMethodForInterface(_class, name) {
            return _class[name.slice(10)] === undefined || typeof _class[name.slice(10)] !== "function";
        };
        function _noAttritubeForInterface(_class, name) {
            return _class[name.slice(10)] === undefined || typeof _class[name.slice(10)] === "function";
        };

        //检查抽象成员
        this.P_addAbstract = function (abstract) {
            var name = "",
                currentClass = this.P_class;

            for (name in abstract) {
                if (abstract.hasOwnProperty(name)) {
                    //抽象方法前面加"Abstract_"前缀
                    currentClass.prototype["Abstract_" + name] = abstract[name];
                    //temp[name] = abstract[name];    //加入temp
                }
            }
        };

        //检查虚方法(不能为虚属性)
        this.P_addVirtual = function (virtual) {
            var name = "",
                currentClass = this.P_class;

            for (name in virtual) {
                if (virtual.hasOwnProperty(name)) {
                    if (typeof virtual[name] !== "function") {
                        throw new Error("Virtual attribute is not allowed!");
                    }
                    else {
                        currentClass.prototype[name] = virtual[name];
                        //temp[name] = virtual[name];    //加入this.temp
                    }
                }
            }
        };

        ////加入密封方法。
        ////没有实现检查子类是否重写了父类的密封方法，只是定义了一个规范。
        //this.P_addSealed = function (sealed, currentClass) {
        //    var name = "";

        //    for (name in sealed) {
        //        if (sealed.hasOwnProperty(name)) {
        //            currentClass.prototype[name] = sealed[name];
        //            //temp[name] = sealed[name];    //加入this.temp
        //        }
        //    }
        //};

        //获得在原型prototype中不存在同名的str。
        //如果有同名，则加上前缀"_"
        this.P_getNoRepeatStrInPrototype = function (prototype, str) {
            var new_str = "";

            if (!prototype[str]) {
                return str;
            }
            new_str = "_" + str;

            return arguments.callee(prototype, new_str);
        };
        this.P_addStatic = function () {
            var Static = null,
                k = null,
                _class = this.P_class,
                prop = this.prop;

            Static = prop.Static ? prop.Static : null;
            //静态属性/方法赋值
            for (k in Static) {
                _class[k] = Static[k];
            }
        };

        this.P_inherit = function () {
            var _class = this.P_class,
                parentClass = this.parentClass;

            _class.prototype = this.P_extendDeep(parentClass.prototype);
            _class.prototype.constructor = _class;

            // 如果父类存在，则实例对象的baseClass指向父类的原型。
            // 这就提供了在实例对象中调用父类方法的途径。
            //baseClass的方法是指向this.parentClass的，不是指向F（子类）的！
            _class.prototype[this.P_getNoRepeatStrInPrototype(parentClass.prototype, "baseClass")] = parentClass.prototype;
        };
        this.P_addInit = function () {
            //var self = this;
            var _class = this.P_class,
                parentClass = this.parentClass,
                prop = this.prop;

            if (prop.Init) {
                // 如果此类继承自父类this.parent并且父类原型中存在同名函数name
                if (parentClass &&
        typeof prop.Init === "function" &&
        typeof _class.prototype.Init === "function") {
                    //if (this.parentClass) {
                    _class.prototype.Init = function (name) {
                        return function () {
                            /*
                            //此处不用创建闭包了！因为外面已经创建了闭包，name已经被保存了！
                            this.baseToParrent = function () {
                                //这个写法也可以！为什么不用apply修正this也行？？！
                                //this.parentClass.prototype[name](); 
        
                                //此处的arguments为baseToParrent方法传入的形参
                                //注意！要加上“return”，这样才能返回this.parentClass.prototype[name]的返回值
                                return this.parentClass.prototype[name].apply(this.parentClass.prototype, arguments);
                            };
                            */
                            //指向子类，可以用于模版模式
                            this.base = parentClass.prototype[name];

                            //执行fn并返回执行的结果
                            //此处的arguments为F.prototype[name]方法传入的形参。
                            return prop[name].apply(this, arguments);
                        };

                    }("Init");
                }
                else {
                    _class.prototype.Init = prop.Init;
                }
            }
        };

        this.P_addPrivate = function () {
            var name = null,
                _class = this.P_class,
                private = this.prop.Private;

            if (private) {
                //私有属性/方法直接覆盖
                for (name in private) {
                    if (private.hasOwnProperty(name)) {
                        _class.prototype[name] = private[name];
                    }
                }
            }
        };

        this.P_prepareAndAddPublic = function () {
            var name = null;

            if (this.prop.Public) {
                for (name in this.prop.Public) {
                    if (this.prop.Public.hasOwnProperty(name)) {
                        if (this.P_prepareCheck("Public", name) === "continue") {
                            continue;
                        }
                        this.P_addPublic(name);
                        this.children[name] = this.prop.Public[name];
                    }
                }
            }
        };

        this.P_addPublic = function (name) {
            var self = this;

            if (this.parentClass &&
                typeof this.prop.Public[name] === "function" &&
                typeof this.P_class.prototype[name] === "function") {
                this.P_class.prototype[name] = function (name) {
                    return function () {
                        /*
                        //此处不用创建闭包了！因为外面已经创建了闭包，name已经被保存了！
                        self.baseToParrent = function () {
                            //这个写法也可以！为什么不用apply修正this也行？？！
                            //this.parentClass.prototype[name](); 
    
                            //此处的arguments为baseToParrent方法传入的形参
                            //注意！要加上“return”，这样才能返回self.parentClass.prototype[name]的返回值
                            return self.parentClass.prototype[name].apply(self.parentClass.prototype, arguments);
                        };
                        */
                        //指向子类，可以用于模版模式
                        this.base = self.parentClass.prototype[name];

                        //执行fn并返回执行的结果
                        //此处的arguments为F.prototype[name]方法传入的形参。
                        return self.prop.Public[name].apply(this, arguments);
                    };

                }(name);
            }
            else {
                this.P_class.prototype[name] = this.prop.Public[name];
            }
        };

        this.P_prepareAndAddProtected = function () {
            var name = null;

            if (this.prop.Protected) {
                for (name in this.prop.Protected) {
                    if (this.prop.Protected.hasOwnProperty(name)) {
                        if (this.P_prepareCheck("Protected", name) === "continue") {
                            continue;
                        }
                        this.P_class.prototype[name] = this.prop.Protected[name];
                        this.children[name] = this.prop.Protected[name];
                    }
                }
            }
        };
    };


    //创建抽象类
    //抽象类能够继承接口、抽象类以及实体类，但此处约定抽象类只能继承接口和抽象类，不能继承实体类！
    //（这样方便判断抽象类是否包含全部的父类（接口/抽象类）成员）

    function AClass() {
        var that = this;

        this.children = {};
        this.P_class = A;

        // 本次调用所创建的类（构造函数）
        function A() {
        }

        var _getByParent = function (_parent, _prop) {
            //if (arguments.length === 1) {
            if (_prop === undefined) {
                that.prop = _parent;
                that.parentClass = null;
                that.interface = null;
            }
            else if (typeof _parent === "object") {

                if (!_parent.Class && !_parent.Interface) {
                    throw new Error("Please add AbstractClass or Interface!");
                }
                if (_getFunctionName(_parent.Class) === "F" || _getFunctionName(_parent.Interface) === "F") {
                    throw new Error("AbstractClass here can't inherit this.parentClass which is created by Class function!");
                }

                that.parentClass = _parent.Class;
                that.interface = _parent.Interface;
                that.prop = _prop;
            }
                //_parent直接为xx，就表示父类为抽象类
            else if (typeof _parent === "function") {
                if (_getFunctionName(_parent) === "F") {
                    throw new Error("AbstractClass here can't inherit this.parentClass which is created by Class function!");
                }

                that.parentClass = _parent;
                that.interface = null;
                that.prop = _prop;
            }
            else {
                throw new Error("arguments is not allowed!");
            }
        };
        this.P_prepareCheck = function (where, name) {
            //检查抽象成员，抽象成员放到Public或Protected中
            if (name === "Abstract") {
                //this.P_addAbstract(this.prop[where][name], A, this.children);
                this.P_addAbstract(this.prop[where][name]);
                return "continue";
            }
            //检查虚方法，虚方法放到Public或Protected中
            if (name === "Virtual") {
                this.P_addVirtual(this.prop[where][name]);
                return "continue";
            }
        };
        this.buildAClass = function (_parent, _prop) {
            //取出父类、接口
            _getByParent(_parent, _prop);

            // 如果此接口需要从其它接口扩展
            if (this.parentClass) {
                this.P_inherit();
            }

            //加入构造函数
            //抽象类本身因为不能实例化，所以不调用构造函数。
            //抽象类中的构造函数供子类构造函数中调用。
            this.P_addInit();

            this.P_addPrivate();

            this.P_prepareAndAddPublic();


            //保护成员
            //_prepareAndAddProtected();
            this.P_prepareAndAddProtected();

            //放到外面的抽象成员，默认为公有抽象成员
            this.P_addAbstract(this.prop.Abstract);

            this.P_addStatic();

            //检查抽象类的公有方法+虚方法+抽象方法是否包含父类的接口方法/属性
            this.P_check(null);

            return A;
        };

    };


    AClass.prototype = new Structure();

    //创建普通类
    //父类_parent可以为{Class: xx, Interface: xx}，或者直接为xx类
    function Class() {
        var that = this;

        this.P_class = F;
        this.children = {};
        //当前是否处于创建类的阶段。
        this.initializing = false;
        //原型恢复标志，用于防止第一次创建实例时恢复原型
        this.mark_resume = false;

        // 本次调用所创建的类（构造函数）
        function F() {
            //防止第一次创建实例时恢复原型
            if (that.mark_resume) {
                //还原原型
                that.P_extendDeep(F.backUp_prototype, F.prototype);
            }
            else {
                that.mark_resume = true;
            }

            // 如果当前处于实例化类的阶段，则调用Init原型函数
            if (!that.initializing) {
                this.Init && this.Init.apply(this, arguments);
            }
            /*不能删除私有成员和保护成员！否则类的成员就不能调用到私有和保护的成员了（因为已经删除了）！
            对象的创建算法参考http://www.cnblogs.com/TomXu/archive/2012/02/06/2330609.html
        
        
        
        
            //删除私有成员和保护成员，这样外界就不能访问私有和保护成员了！
            for (name in this) {
            if (name.search(/(^_)|(^P_)/) !== -1) {
            delete F.prototype[name];
            //                                                    this[name] = null;
            }
              
            }
            */
        }

        var _getByParent = function (_parent, _prop) {
            //if (arguments.length === 1) {
            if (_prop === undefined) {
                that.prop = _parent;
                that.parentClass = null;
                that.interface = null;
            }
                //{Class: xx, Interface: xx}
            else if (typeof _parent === "object") {
                if (!_parent.Class && !_parent.Interface) {
                    throw new Error("Please add Class or Interface!");
                }

                that.parentClass = _parent.Class;
                that.interface = _parent.Interface;
                that.prop = _prop;
            }
                //直接为xx类
            else if (typeof _parent === "function") {
                that.parentClass = _parent;
                that.interface = null;
                that.prop = _prop;
            }
            else {
                throw new Error("arguments is not allowed!");
            }
        };
        //this._addParentSealed = function () {
        //    var name = null;

        //    for (name in this.parentClass.prototype) {
        //        if (this.parentClass.prototype.hasOwnProperty(name)) {
        //            //如果不是抽象方法/保护方法/私有方法/接口成员，则加入到this.temp中。
        //            //用于添加父类的密封方法（因为子类并没有加入父类的密封方法）。
        //            if (!name.match(/^Abstract_/) || !name.match(/^P_/) || !name.match(/^_/) || !name.match(/^Interface_/)) {
        //                this.children[name] = this.parentClass.prototype[name];
        //            }
        //        }
        //    }
        //};
        this.P_prepareCheck = function (where, name) {
            //检查虚方法，虚方法放到Public或Protected中
            if (name === "Virtual") {
                this.P_addVirtual(this.prop[where][name]);
                return "continue";
            }
            ////密封的方法（不允许子类重写）
            //if (name === "Sealed") {
            //    this.P_addSealed(this.prop[where][name], A);
            //    return "continue";
            //}

            return null;
        };

        this.buildClass = function (_parent, _prop) {
            _getByParent(_parent, _prop);

            // 如果此类需要从其它类扩展
            if (this.parentClass) {
                this.initializing = true;
                this.P_inherit();
                this.initializing = false;
            }

            this.P_addInit();

            this.P_addPrivate();

            //保护成员
            this.P_prepareAndAddProtected();

            if (this.prop.Abstract) {
                throw new Error("Only abstractClass can have abstract methods!");
            }
            this.P_prepareAndAddPublic();

            //检查公有成员和虚函数是否实现了抽象方法/属性 或 接口方法/属性
            this.P_check();

            this.P_addStatic();

            //备份原型
            F.backUp_prototype = this.P_extendDeep(F.prototype);

            return F;
        };
    };

    Class.prototype = new Structure();

    /*
    下面的写法有问题！因为只有载入oopFrame.js时，创建了AClass的实例。
    调用YYC.AClass时，只是引用该实例的buildAClass，而不会再创建AClass实例。
    也就是说，所有YYC.AClass都共用一个AClass的实例！共用AClass实例的属性（如parent等）！

    YYC.AClass = new AClass().buildAClass;
    */


    YYC.AClass = function (_parent, _prop) {
        return new AClass().buildAClass(_parent, _prop);
    };
    YYC.Class = function (_parent, _prop) {
        return new Class().buildClass(_parent, _prop);
    };
}());

重构Interface

去掉i、args变量，提取出buildInterface方法，用oo思想重构Interface：

function Interface() {
    var that = this;

    this.parent = null;
    this.method = null;
    this.attribute = null;

    function I() {
    }

    function _getByParent(_parent, _method, _attribute) {
        if (typeof _parent === "function") {
            if (_getFunctionName(_parent) !== "I") {
                throw new Error("Interface must inherit interface!");
            }
            else {
                that.parent = _parent;
                //形如“Interface(Parent, "A", "B", "GetName");”
                if (_method && !_isArray(_method)) {
                    that.method = Array.prototype.slice.call(arguments, 1);
                    that.attribute = null;
                }
                    //形如“Interface(Parent, ["A", "B", "GetName"], ["a", "c"]);”
                else {
                    that.method = _method;
                    that.attribute = _attribute;
                }
            }
        }
        else {
            that.parent = null;
            //形如“Interface("A", "B", "GetName");”
            if (_method && !_isArray(_method)) {
                that.method = Array.prototype.slice.call(arguments, 0);
                that.attribute = null;
            }
                //形如“Interface(["A", "B", "GetName"], ["a", "c"]);”
            else {
                that.method = arguments[0];
                that.attribute = arguments[1];
            }
        }
    };
    function _inherit() {
        I.prototype = new that.parent();
        I.prototype.constructor = I;
    };
    function _addMethod() {
        var i = 0,
            len = 0;

        for (i = 0, len = that.method.length; i < len; i++) {
            //加上前缀“Interface_”
            I.prototype["Interface_" + that.method[i]] = function () {
                throw new Error("This method must be overwrited!");
            };
        }
    };
    function _addAttribute() {
        var i = 0,
            len = 0;

        if (that.attribute) {
            if (!_isArray(that.attribute)) {
                throw new Error("Attribute must be array!");
            }
            else {
                for (i = 0, len = that.method.length; i < len; i++) {
                    //加上前缀“Interface_”
                    I.prototype["Interface_" + that.attribute[i]] = 0;
                }
            }
        }
    };

    this.buildInterface = function (_parent, _method, _attribute) {
        _getByParent(_parent, _method, _attribute);
        // 如果此接口需要从其它接口扩展
        if (this.parent) {
            _inherit();
        }
        //方法
        _addMethod();
        //属性
        _addAttribute();

        return I;
    };
};

增加测试

增加测试"子类虚方法实现抽象父类的抽象方法时，不抛出异常"、"非抽象类定义抽象成员时抛出异常"：

it("子类虚方法实现抽象父类的抽象方法时，不抛出异常", function () {
    var A = YYC.AClass({
        Abstract: {
            move: function () { }
        }
    });
    expect(function () {
        YYC.Class(A, {
            Public: {
                Virtual: {
                    move: function () { }
                }
            }
        });
    }).not.toThrow();
});
it("非抽象类定义抽象成员时抛出异常", function () {
    expect(function () {
        YYC.Class({
            Protected: {
                Abstract: {
                    move: function () { }
                }
            }
        });
    }).toThrow();
    expect(function () {
        YYC.Class({
            Abstract: {
                move: function () { }
            }
        });
    }).toThrow();
});

重构children

之前将temp改名为children，但是现在发现这个名字也不恰当，因此根据它的职责“存储该类成员的名称，从而用于检查该类成员是否实现了接口或者父类的抽象成员。”，将其改名为impletationMap。

将“存储该类成员的名称”的操作封装为函数P_addToImplementMap，放到Structure中：

this.P_addToImplementMap = function (name, func) {
    this.implementaionMap[name] = func;
};

然后又经过了下面的重构

• 将Structure -> P_prepareAndAddProtected、P_prepareAndAddPublic、P_addVirtual中“将实现方法加入到ImpletationMap中”的职责提取出来形成P_prepareCheck方法，并将原方法改名为P_addPublicMember、P_addProtectedMember。
• 将Structure ->P_addPrivate、P_addStatic改名为P_addPrivateMember、P_addStaticMember。
• 将buildClass、buildAClass中的加入外部的抽象成员职责提取为_addOuterAbstract方法。
• 将Class -> F中恢复F.prototype和初始化职责分别提取为_restorePrototype、_init方法。
• 将Structure的实例属性下移到子类中。

性能优化

为了优化性能，减少占用的内存，考虑将Interface、Structure、AClass、Class的实例成员改写成原型成员。

重构Struture后，Structure的结构为：

function Structure() {
};
Structure.prototype = (function () {}());

当我将AClass改写成原型形式后，发现测试不能通过，原来是如果写成原型形式，则AClass的实例就共享同一个内部函数A！这样会造成不同的类之间互相干扰！

因此，没有对Interface、AClass、Class进行该重构。

改变原有的行为

我需要增加“支持继承多个接口”，因此我先添加了测试用例，然后实现。另外我需要增加“限制只能最多继承一个类”，因此我也先添加测试用例，然后加入限制。

在改变代码原有行为时，可能需要改变或增加相应的测试用例。那么不用迟疑，立刻就去做。

重构注释

删除不必要的注释，添加重要的算法说明、重构说明等注释。

尽量少些注释，通过对类、函数、属性等的命名来体现职责和目的。

以下来自《代码整洁之道》，可作为参考：
好注释：法律信息，提供信息的注释，对意图的解释，阐释，警示，TODO注释，放大，共用API中的javadoc
坏注释：喃喃自语，多余的注释，误导性的注释，循规式的注释，日志式注释，废话注释，可怕的废话，能用函数或变量时就别用注释，位置标记，括号后面的注释，归属与署名，注释掉的代码，函数头，非共用API中的javadoc。

完成重构

最终的测试代码：

describe("YOOP", function () {
    it("不存在虚属性的概念（如果企图声明虚属性，会抛出异常）", function () {
        expect(function () {
            YYC.Class({
                Virtual: {
                    a: ""
                }
            });
        }).toThrow();
        expect(function () {
            YYC.AClass({
                Virtual: {
                    a: ""
                }
            });
        }).toThrow();
    });
    it("静态方法的this是指向类的", function () {
        var A = YYC.Class({
            Static: {
                a: 100,
                method: function () {
                    this.b = 300;
                    return 200;
                }
            }
        });
        var result = A.method();

        expect(result).toEqual(200);
        expect(A.b).toEqual(300);    //300
    });

    describe("测试Class与AClass", function () {
        function testInheritFromOnlyOneClass(_class) {
            var A = YYC.AClass({});
            var B = YYC.AClass({});

            expect(function () {
                YYC[_class](A, B, {});
            }).toThrow();
            expect(function () {
                YYC[_class]({ Class: [A, B] }, {});
            }).toThrow();
        };

        describe("测试类Class", function () {
            it("可以继承多个接口。如果不实现会抛出异常", function () {
                var A = YYC.Interface("m1");
                var B = YYC.Interface("m2");

                expect(function () {
                    YYC.Class({ Interface: A }, {
                        Public: {
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class({ Interface: [A] }, {
                        Public: {
                        }
                    });
                }).toThrow();

                expect(function () {
                    YYC.Class({ Interface: [A, B] }, {
                        Public: {
                            m1: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class({ Interface: [A, B] }, {
                        Public: {
                            m2: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class({ Interface: [A, B] }, {
                        Public: {
                            m1: function () { },
                            m2: function () { }
                        }
                    });
                }).not.toThrow();
            });

            it("只能继承一个类（Class或AClass），否则抛出异常", function () {
                testInheritFromOnlyOneClass("Class");
            });
            it("创建实例时调用构造函数", function () {
                var A = YYC.Class({
                    Init: function () {
                        this.a = 10;
                    }
                });

                expect(new A().a).toEqual(10);
            });

            describe("获得公有成员", function () {
                it("如果父类不存在，能够正确获得公有方法", function () {
                    var Class = YYC.Class({
                        Public: {
                            a: function () {
                                this.b = 1;
                                return 0;
                            }
                        }
                    });

                    var cla = new Class();
                    var result = cla.a();

                    expect(result).toEqual(0);
                    expect(cla.b).toEqual(1);
                });
            });
            it("不能定义抽象成员，否则抛出异常", function () {
                expect(function () {
                    YYC.Class({
                        Public: {
                            Abstract: {
                                move: function () { }
                            }
                        }
                    })
                }).toThrow();
            });
            it("可以将虚方法定义在外面，表示公有虚方法", function () {
                var A = YYC.Class({
                    Virtual: {
                        move: function () { }
                    }
                });

                expect(function () {
                    new A().move()
                }).not.toThrow();
            });
            it("验证是否实现了接口成员，如果没有实现会抛出异常", function () {
                var I = YYC.Interface(["move"], ["a"]);

                expect(function () {
                    YYC.Class({ Interface: I }, {
                        Public: {
                            a: 0
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class({ Interface: I }, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class({ Interface: I }, {
                        Public: {
                            a: 0,
                            move: function () { }
                        }
                    });
                }).not.toThrow();
            });
            it("验证是否实现了父类抽象成员，如果没有实现会抛出异常", function () {
                var A = YYC.AClass({
                    Abstract: {
                        move: function () { },
                        a: 0
                    }
                });

                expect(function () {
                    YYC.Class(A, {
                        Public: {
                            a: 0
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(A, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(A, {
                        Public: {
                            a: 0,
                            move: function () { }
                        }
                    });
                }).not.toThrow();
            });
        });

        describe("测试抽象类AClass", function () {
            it("可以继承多个接口（在抽象类中不用实现，可以交给子类Class实现）", function () {
                var A = YYC.Interface("m1");
                var B = YYC.Interface(["m2"], ["a"]);
                var C = YYC.AClass({ Interface: [A, B] }, {});

                expect(function () {
                    YYC.Class(C, {
                        Public: {
                            m1: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(C, {
                        Public: {
                            m2: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(C, {
                        Public: {
                            m1: function () { },
                            m2: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(C, {
                        Public: {
                            m1: function () { },
                            m2: function () { },
                            a: 1
                        }
                    });
                }).not.toThrow();
            });
            it("只能继承一个类（Class或AClass），否则抛出异常", function () {
                testInheritFromOnlyOneClass("AClass");
            });
            it("构造函数供子类调用", function () {
                var A = YYC.AClass({
                    Init: function () {
                        throw new Error();
                    }
                });
                var B = YYC.Class(A, {
                    Init: function () {
                        this.a = 10;
                    }
                });
                var C = YYC.Class(A, {
                    Init: function () {
                        this.a = 10;
                        this.base();
                    }
                });

                expect(function () {
                    new B();
                }).not.toThrow();
                expect(function () {
                    new C();
                }).toThrow();

            });
            it("抽象类如果继承实体类，会抛出异常", function () {
                var A = YYC.Class({});
                expect(function () {
                    YYC.AClass(A, {});
                }).toThrow();
            });
            it("子类虚方法实现抽象父类的抽象方法时，不抛出异常", function () {
                var A = YYC.AClass({
                    Abstract: {
                        move: function () { }
                    }
                });
                expect(function () {
                    YYC.Class(A, {
                        Public: {
                            Virtual: {
                                move: function () { }
                            }
                        }
                    });
                }).not.toThrow();

                expect(function () {
                    YYC.Class(A, {
                        Public: {
                        }
                    });
                }).toThrow();
            });
            it("可以将虚方法定义在外面，表示公有虚方法", function () {
                var A = YYC.AClass({
                    Virtual: {
                        move: function () { }
                    }
                });
                var B = YYC.Class(A, {});

                expect(function () {
                    new B().move()
                }).not.toThrow();
            });
            it("可以将抽象成员定义在外面，表示公有抽象成员", function () {
                var A = YYC.AClass({
                    Abstract: {
                        move: function () { }
                    }
                });

                expect(function () {
                    YYC.Class(A, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).not.toThrow();
            });
            it("不验证是否实现父类的抽象成员（可以交给子类Class实现）", function () {
                var A = YYC.AClass({
                    Abstract: {
                        move: function () { },
                        a: 0
                    }
                });
                var B = YYC.AClass(A, {});
                var C = YYC.AClass(B, {});

                expect(function () {
                    YYC.AClass(A, {
                        Public: {
                            a: 0
                        }
                    });
                }).not.toThrow();
                expect(function () {
                    YYC.AClass(A, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).not.toThrow();


                expect(function () {
                    YYC.Class(B, {
                        Public: {}
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(B, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).toThrow();
                expect(function () {
                    YYC.Class(B, {
                        Public: {
                            move: function () { },
                            a: 1
                        }
                    });
                }).not.toThrow();


                expect(function () {
                    YYC.Class(C, {
                        Public: {
                            move: function () { }
                        }
                    });
                }).toThrow();
            });
            it("子类没有全部实现抽象父类的抽象成员时，抛出异常", function () {
                var A = YYC.AClass({
                    Init: function (t) {
                        this.a = t;
                        this.b = 2;
                    },
                    Public: {
                        p: function () {
                            return 0;
                        }
                    },
                    Private: {
                        _m: 1
                    },
                    Protected: {
                        P_h: function () {
                            return this._m;
                        },
                        P_k: 3
                    },
                    Abstract: {
                        move: function () { },
                        u: 0,
                        t: function () { }
                    }
                });

                expect(function () {
                    YYC.Class(A, {
                        Init: function () {
                            this.b = 100;
                            this.base(200);
                        },
                        Public: {
                            u: 20
                        }
                    });
                }).toThrow();
            });
            it("子类全部实现抽象父类的抽象成员时，不抛出异常", function () {
                var A = YYC.AClass({
                    Init: function (t) {
                        this.a = t;
                        this.b = 2;
                    },
                    Public: {
                        p: function () {
                            return 0;
                        }
                    },
                    Private: {
                        _m: 1
                    },
                    Protected: {
                        P_h: function () {
                            return this._m;
                        },
                        P_k: 3
                    },
                    Abstract: {
                        move: function () { },
                        u: 0,
                        t: function () { }
                    }
                });
                var B = YYC.Class(A, {
                    Init: function () {
                        this.b = 100;
                        this.base(200);
                    },
                    Public: {
                        move: function () {
                            return this.P_h();
                        },
                        t: function () { },
                        u: 20
                    }
                });
                var C = YYC.Class(B, {
                    Public: {
                        move: function () {
                            var baseResult = this.base();

                            return baseResult;
                        },
                        t: function () { }
                    }
                });

                var b = new B();
                var c = new C();

                expect([b.a, b.b]).toEqual([200, 2]);
                expect([b.p(), b.move(), b.u]).toEqual([0, 1, 20]);
                expect(c.move()).toEqual(1);
            });
        });
    });


    describe("测试接口Interface", function () {
        it("可以继承多个接口", function () {
            var A = YYC.Interface("m1");
            var B = YYC.Interface("m2");
            var C = YYC.Interface([A, B], "m3");
            var D = YYC.Interface([A, B], ["m3"]);
            var E = YYC.Interface([A, B], ["m3"], ["a"]);
            var F = YYC.Interface(A, "m2");

            expect(C.prototype.Interface_m1).toBeExist();
            expect(C.prototype.Interface_m2).toBeExist();
            expect(C.prototype.Interface_m3).toBeExist();

            expect(D.prototype.Interface_m1).toBeExist();
            expect(D.prototype.Interface_m2).toBeExist();
            expect(D.prototype.Interface_m3).toBeExist();

            expect(E.prototype.Interface_m1).toBeExist();
            expect(E.prototype.Interface_m2).toBeExist();
            expect(E.prototype.Interface_m3).toBeExist();
            expect(E.prototype.Interface_a).toEqual(0);

            expect(F.prototype.Interface_m1).toBeExist();
            expect(F.prototype.Interface_m2).toBeExist();
        });
    });

    describe("集成测试", function () {
        it("测试解决“若父类的属性为引用类型（数组或对象）a，则如果子类的实例s1对a进行修改或者sub调用修改a的方法，则第二次创建实例s2的a为修改过后的a！”的问题", function () {
            var Parent = YYC.AClass({
                Init: function () {
                    console.log("Parent Init!");
                },
                Public: {
                    a: [],
                }
            });
            var Sub = YYC.Class(Parent, {
                Init: function () {
                },
                Public: {
                }
            });

            var t = new Sub();
            t.a.push("a");
            var m = new Sub();

            expect(m.a).toEqual([]);
        });
        it("测试解决“若父类Parent的属性为引用类型（数组或对象）a，有两个子类Sub1、Sub2。如果子类Sub1的实例s1对a进行修改或者sub调用修改a的方法，则子类Sub2的实例的a为修改过后的a！”的问题", function () {
            var Parent = YYC.AClass({
                Init: function () {
                    console.log("Parent Init!");
                },
                Public: {
                    a: [],
                    add: function () {
                        this.a.push("a");
                    }
                }
            });
            var Sub1 = YYC.Class(Parent, {
                Init: function () {
                },
                Public: {
                }
            });
            var Sub2 = YYC.Class(Parent, {
                Init: function () {
                }
            });

            var t = new Sub1();
            t.a.push("a");
            var k = new Sub2();

            expect(k.a).toEqual([]);

        });
        it("测试解决“若A1为抽象类，A2（抽象类）继承于A1，B（类）继承于A2，A1、A2、B都有同名方法a，A2和B在a方法中都通过this.baseClass调用父类同名方法。则如果B的实例b调用a方法，则A2、B的a方法中的this.baseClass均指向A2（照理说A2的this.baseClass应该指向A1）！”的问题", function () {
            var A1 = YYC.AClass({
                Public: {
                    arr: [],
                    a: function () {
                        this.arr.push(1);
                    }
                }
            });
            var A2 = YYC.AClass(A1, {
                Public: {
                    a: function () {
                        this.arr.push(2);
                        this.baseClass.a.call(this, null);
                    }
                }
            });
            var B = YYC.Class(A2, {
                Public: {
                    a: function () {
                        this.arr.push(3);
                        this._baseClass.a.call(this, null);

                        return this.arr;
                    }
                }
            });
            var b = new B();

            expect(b.a()).toEqual([3, 2, 1]);
        });
    });
});

最终的YOOP代码：

(function () {

    window.YYC = window.YYC || {};

    /************************************************** String对象扩展 ************************************************************/
    if (!String.prototype.contain) {
        String.prototype.contain = function (str) {
            var reg = new RegExp(str);  //str需要转义
            if (this.match(reg)) {
                return true;
            }
            else {
                return false;
            }
        }
    }

    /*****************************************************************************************************************************/
        //获得在原型prototype中不存在同名的str。
        //如果有同名，则加上前缀"_"
    function getNoRepeatStrInPrototype(prototype, str) {
        var new_str = "";

        if (!prototype[str]) {
            return str;
        }
        new_str = "_" + str;

        return arguments.callee(prototype, new_str);
    }


    function extendDeep(parent, child) {
        var i = null,
            len = 0,
            toStr = Object.prototype.toString,
            sArr = "[object Array]",
            sOb = "[object Object]",
            type = "",
            _child = null;

        //数组的话，不获得Array原型上的成员。
        if (toStr.call(parent) === sArr) {
            _child = child || [];

            for (i = 0, len = parent.length; i < len; i++) {
                type = toStr.call(parent[i]);
                if (type === sArr || type === sOb) {    //如果为数组或object对象
                    _child[i] = type === sArr ? [] : {};
                    arguments.callee(parent[i], _child[i]);
                } else {
                    _child[i] = parent[i];
                }
            }
        }
        //对象的话，要获得原型链上的成员。因为考虑以下情景：
        //类A继承于类B，现在想要拷贝类A的实例a的成员（包括从类B继承来的成员），那么就需要获得原型链上的成员。
        else if (toStr.call(parent) === sOb) {
            _child = child || {};

            for (i in parent) {
                type = toStr.call(parent[i]);
                if (type === sArr || type === sOb) {
                    _child[i] = type === sArr ? [] : {};
                    arguments.callee(parent[i], _child[i]);
                } else {
                    _child[i] = parent[i];
                }
            }
        }
        else {
            _child = parent;
        }

        return _child;
    };
    function getFunctionName(fn) {
        var name = "";

        if (!fn) {
            return null;
        }

        name = fn.toString().match(/^.*function\s*([^\(]*)/);
        return name === null ? name : name[1];
    };

    function isArray(val) {
        return Object.prototype.toString.call(val) === "[object Array]";
    };

    /*
     Structure写成原型形式，而Interface、AClass、Class不写成原型形式！（如写成:
     Interface.prototype = (function(){
     function I(){
     };

     return {
     ...
     };
     }());
     ）
     因为如果写成原型形式，则Interface/AClass/Class的实例就共享同一个I/A/F类！这样会造成不同的类之间互相干扰！
     */


    (function () {
        function Interface() {
            var that = this;

            this.parent = null;
            this.method = null;
            this.attribute = null;

            function I() {
            }

            function _getByParent(_parent, _method, _attribute) {
                if (_hasParent(_parent)) {
                    _checkInheritInterface(_parent);
                    that.parent = isArray(_parent) ? _parent : [_parent];

                    //形如“Interface(Parent, "A", "B", "GetName");”
                    if (_method && !isArray(_method)) {
                        that.method = Array.prototype.slice.call(arguments, 1);
                        that.attribute = null;
                    }
                    //形如“Interface(Parent, ["A", "B", "GetName"], ["a", "c"]);”
                    else {
                        that.method = _method;
                        that.attribute = _attribute;
                    }
                }
                else {
                    that.parent = null;
                    //形如“Interface("A", "B", "GetName");”
                    if (_parent && !isArray(_parent)) {
                        that.method = Array.prototype.slice.call(arguments, 0);
                        that.attribute = null;
                    }
                    //形如“Interface(["A", "B", "GetName"], ["a", "c"]);”
                    else {
                        that.method = arguments[0];
                        that.attribute = arguments[1];
                    }
                }

                _checkMethod();
            };
            function _hasParent(_parent) {
                return typeof _parent === "function" || (isArray(_parent) && typeof _parent[0] === "function");
            };
            function _checkInheritInterface(_parent) {
                var i = 0,
                    len = 0;

                for (i = 0, len = _parent.length; i < len; i++) {
                    if (getFunctionName(_parent[i]) !== "I") {
                        throw new Error("Interface must inherit interface!");
                    }
                }
            };
            function _checkMethod() {
                if (!that.method) {
                    throw new Error("Interface must has methods");
                }
            };
            function _inherit() {
                var i = 0,
                    len = 0;

                for (i = 0, len = that.parent.length; i < len; i++) {
                    extendDeep(that.parent[i].prototype, I.prototype);
                }
                I.prototype.constructor = I;
            };
            function _addMethod() {
                var i = 0,
                    len = 0;

                for (i = 0, len = that.method.length; i < len; i++) {
                    if (that.method[i] === undefined) {
                        continue;
                    }
                    //加上前缀“Interface_”
                    I.prototype["Interface_" + that.method[i]] = function () {
                        throw new Error("This method must be overwrited!");
                    };
                }
            };
            function _addAttribute() {
                var i = 0,
                    len = 0;

                if (that.attribute) {
                    if (!isArray(that.attribute)) {
                        throw new Error("Attribute must be array!");
                    }
                    else {
                        for (i = 0, len = that.method.length; i < len; i++) {
                            //加上前缀“Interface_”
                            I.prototype["Interface_" + that.attribute[i]] = 0;
                        }
                    }
                }
            };

            this.buildInterface = function (_parent, _method, _attribute) {
                _getByParent(_parent, _method, _attribute);
                if (this.parent) {
                    _inherit();
                }
                _addMethod();
                _addAttribute();

                return I;
            };
        };

        YYC.Interface = function (_parent, _method, _attribute) {
            return new Interface().buildInterface(_parent, _method, _attribute);
        };
    }());

    (function () {

        function Structure() {
        };
        Structure.prototype = (function () {
            return {
                _addToImplementMap: function (name, func) {
                    this.implementaionMap[name] = func;
                },
                _prepareCheckFor: function (module) {
                    var name = null;

                    if (module) {
                        for (name in module) {
                            if (module.hasOwnProperty(name)) {
                                this._prepareCheckForSpecial(name, module);
                                this._addToImplementMap(name, module[name]);
                            }
                        }
                    }
                },
                _prepareCheckForSpecial: function (name, module) {
                    this._addVirtualToImplementMap(name, module);
                },
                _addVirtualToImplementMap: function (name, module) {
                    var name2 = "";

                    if (name === "Virtual") {
                        for (name2 in module[name]) {
                            if (module[name].hasOwnProperty(name2)) {
                                this._addToImplementMap(name2, module[name][name2]);
                            }
                        }
                    }
                },
                P_checkImplementationOfAbstract: function () {
                    var name = "",
                        parentClass = this.parentClass;

                    if (this.parentClass) {
                        for (name in parentClass.prototype) {
                            if (parentClass.prototype.hasOwnProperty(name)) {
                                if (name === "constructor") {
                                    continue;
                                }
                                if (name.contain("Abstract_")) {
                                    if (typeof parentClass.prototype[name] === "function") {
                                        this._checkAbstractMethod(name);
                                    }
                                    else {
                                        this._checkAbstractAttribute(name);
                                    }
                                }
                            }
                        }
                    }
                },
                _checkAbstractMethod: function (name) {
                    var parentClass = this.parentClass,
                        implementaionMap = this.implementaionMap;

                    if (this._noMethodForAbstract(implementaionMap, name) && this._noMethodForAbstract(parentClass.prototype, name)) {
                        throw new Error("Abstract method '" + name + "' must be overwrited!");
                    }
                },
                _checkAbstractAttribute: function (name) {
                    var parentClass = this.parentClass,
                        implementaionMap = this.implementaionMap;

                    if (this._noAttritubeForAbstract(implementaionMap, name) && this._noAttritubeForAbstract(parentClass.prototype, name)) {
                        throw new Error("Abstract attribute '" + name + "' must be overwrited!");
                    }
                },
                P_checkImplementationOfInterface: function (_interface) {
                    var name = "";

                    for (name in _interface.prototype) {
                        if (!name.contain("Interface_")) {
                            continue;
                        }
                        if (typeof _interface.prototype[name] === "function") {
                            this._checkInterfaceMethod(name);
                        }
                        else {
                            this._checkInterfaceAttribute(name);
                        }
                    }
                },
                _checkInterfaceMethod: function (name) {
                    var implementaionMap = this.implementaionMap,
                        parentClassPrototype = this.parentClass ? this.parentClass.prototype : {};

                    if (this._noMethodForInterface(implementaionMap, name) && this._noMethodForInterface(parentClassPrototype, name)) {
                        throw new Error("Interface method '" + name + "' must be overwrited!");
                    }
                },
                _checkInterfaceAttribute: function (name) {
                    var implementaionMap = this.implementaionMap,
                        parentClassPrototype = this.parentClass ? this.parentClass.prototype : {};

                    if (this._noAttritubeForInterface(implementaionMap, name) && this._noAttritubeForInterface(parentClassPrototype, name)) {
                        throw new Error("Interface attribute '" + name + "' must be overwrited!");
                    }
                },
                _noMethodForAbstract: function (_class, name) {
                    return _class[name.slice(9)] === undefined || typeof _class[name.slice(9)] !== "function";
                },
                _noAttritubeForAbstract: function (_class, name) {
                    return _class[name.slice(9)] === undefined || typeof _class[name.slice(9)] === "function";
                },
                _noMethodForInterface: function (_class, name) {
                    return _class[name.slice(10)] === undefined || typeof _class[name.slice(10)] !== "function";
                },
                _noAttritubeForInterface: function (_class, name) {
                    return _class[name.slice(10)] === undefined || typeof _class[name.slice(10)] === "function";
                },
                P_addAbstract: function (abstract) {
                    var name = "",
                        _class = this.P_class;

                    for (name in abstract) {
                        if (abstract.hasOwnProperty(name)) {
                            //抽象方法前面加"Abstract_"前缀
                            _class.prototype["Abstract_" + name] = abstract[name];
                        }
                    }
                },
                //加入虚方法(不能为虚属性)
                P_addVirtualAndCheck: function (virtual) {
                    var name = "",
                        _class = this.P_class;

                    for (name in virtual) {
                        if (virtual.hasOwnProperty(name)) {
                            if (typeof virtual[name] !== "function") {
                                throw new Error("Virtual attribute is not allowed!");
                            }
                            else {
                                _class.prototype[name] = virtual[name];
                            }
                        }
                    }
                },
                P_addStaticMember: function () {
                    var Static = null,
                        k = null,
                        _class = this.P_class,
                        prop = this.prop;

                    Static = prop.Static ? prop.Static : null;

                    for (k in Static) {
                        _class[k] = Static[k];
                    }
                },
                P_inherit: function () {
                    var _class = this.P_class,
                        parentClass = this.parentClass;

                    _class.prototype = extendDeep(parentClass.prototype);
                    _class.prototype.constructor = _class;

                    // 如果父类存在，则实例对象的baseClass指向父类的原型。
                    // 这就提供了在实例对象中调用父类方法的途径。
                    //baseClass的方法是指向this.parentClass.prototype的，不是指向（子类）的！
                    _class.prototype[getNoRepeatStrInPrototype(parentClass.prototype, "baseClass")] = parentClass.prototype;
                },
                P_addInit: function () {
                    var _class = this.P_class,
                        parentClass = this.parentClass,
                        prop = this.prop;

                    if (prop.Init) {
                        if (parentClass &&
                            typeof prop.Init === "function" &&
                            typeof _class.prototype.Init === "function") {
                            _class.prototype.Init = function (name) {
                                return function () {
                                    this.base = parentClass.prototype[name];

                                    return prop[name].apply(this, arguments);
                                };
                            }("Init");
                        }
                        else {
                            _class.prototype.Init = prop.Init;
                        }
                    }
                },
                P_addPrivateMember: function () {
                    var name = null,
                        _class = this.P_class,
                        private = this.prop.Private;

                    if (private) {
                        for (name in private) {
                            if (private.hasOwnProperty(name)) {
                                _class.prototype[name] = private[name];
                            }
                        }
                    }
                },
                P_addPublicMember: function () {
                    var name = null;

                    if (this.prop.Public) {
                        for (name in this.prop.Public) {
                            if (this.prop.Public.hasOwnProperty(name)) {
                                if (this.P_addSpecial("Public", name) === "continue") {
                                    continue;
                                }
                                this._addPublic(name);
                            }
                        }
                    }
                },
                _addPublic: function (name) {
                    var parentClass = this.parentClass,
                        prop = this.prop,
                        P_class = this.P_class;

                    if (parentClass &&
                        typeof prop.Public[name] === "function" &&
                        typeof P_class.prototype[name] === "function") {
                        P_class.prototype[name] = function (name) {
                            return function () {
                                this.base = parentClass.prototype[name];

                                return prop.Public[name].apply(this, arguments);
                            };
                        }(name);
                    }
                    else {
                        P_class.prototype[name] = prop.Public[name];
                    }
                },
                P_prepareCheck: function () {
                    this._prepareCheckFor(this.prop.Public);
                    this._prepareCheckFor(this.prop.Protected);
                },
                P_addProtectedMember: function () {
                    var name = null;

                    if (this.prop.Protected) {
                        for (name in this.prop.Protected) {
                            if (this.prop.Protected.hasOwnProperty(name)) {
                                if (this.P_addSpecial("Protected", name) === "continue") {
                                    continue;
                                }
                                this.P_class.prototype[name] = this.prop.Protected[name];
                            }
                        }
                    }
                }
            }
        }());

        //创建抽象类
        //抽象类能够继承接口、抽象类以及实体类，但此处约定抽象类只能继承接口和抽象类，不能继承实体类！
        //（这样方便判断抽象类是否包含全部的父类（接口/抽象类）成员）

        function AClass() {
            var that = this;

            this.P_class = A;
            this.implementaionMap = {};
            this.parentClass = null;
            this.interface = null;
            this.prop = null;

            // 创建的类（构造函数）
            function A() {
            };

            function __getByParent(args) {
                var _parent = args[0],
                    _prop = args[1];

                __checkOnlyOneParentClass(args);

                if (_prop === undefined) {
                    that.prop = _parent;
                    that.parentClass = null;
                    that.interface = null;
                }
                //{Class: xx, Interface: xx}
                else if (typeof _parent === "object") {
                    if (!_parent.Class && !_parent.Interface) {
                        throw new Error("Please add AbstractClass or Interface!");
                    }
                    that.parentClass = _parent.Class;
                    if (isArray(_parent.Interface)) {
                        that.interface = _parent.Interface;
                    }
                    else if (typeof _parent.Interface === "function") {
                        that.interface = [_parent.Interface];
                    }
                    that.prop = _prop;
                }
                //直接为xx抽象类
                else if (typeof _parent === "function") {
                    that.parentClass = _parent;
                    that.interface = null;
                    that.prop = _prop;
                }
                else {
                    throw new Error("arguments is not allowed!");
                }
                if (__isInheritFromClass()) {
                    throw new Error("AbstractClass can't inherit class!");
                }
            };
            function __checkOnlyOneParentClass(args) {
                if (args.length >= 3) {
                    throw new Error("AbstractClass can only inherit from one parentClass");
                }

                if (args[0].Class) {
                    if (isArray(args[0].Class) && args[0].Class.length >= 2) {
                        throw new Error("AbstractClass can only inherit from one parentClass");
                    }
                }
            };
            function __isInheritFromClass() {
                return getFunctionName(that.parentClass) === "F";
            };
            this.P_inherit = function () {
                var parentClass = this.parentClass;

                if (this.parentClass) {
                    A.prototype = extendDeep(parentClass.prototype);
                    A.prototype.constructor = A;

                    // 如果父类存在，则实例对象的baseClass指向父类的原型。
                    // 这就提供了在实例对象中调用父类方法的途径。
                    //baseClass的方法是指向this.parentClass.prototype的，不是指向（子类）的！
                    A.prototype[getNoRepeatStrInPrototype(parentClass.prototype, "baseClass")] = parentClass.prototype;
                }

                if (this.interface) {
                    var i = 0,
                        len = 0;

                    for (i = 0, len = this.interface.length; i < len; i++) {
                        extendDeep(this.interface[i].prototype, A.prototype);
                    }
                }
            };
            this.P_addSpecial = function (moduleName, name) {
                if (name === "Abstract") {
                    this.P_addAbstract(this.prop[moduleName][name]);
                    return "continue";
                }
                if (name === "Virtual") {
                    this.P_addVirtualAndCheck(this.prop[moduleName][name]);
                    return "continue";
                }
                return null;
            };

            this.buildAClass = function (args) {
                __getByParent(args);

                this.P_inherit();

                //抽象类本身因为不能实例化，所以不在A中调用构造函数Init。
                //抽象类中的构造函数供子类构造函数中调用。
                this.P_addInit();
                this.P_addPrivateMember();
                this.P_addProtectedMember();
                this.P_addPublicMember();
                this.P_addStaticMember();
                __addOuterAbstract();
                __addOuterVirtual();

                this.P_prepareCheck();

                return A;
            };

            //放到外面的抽象成员，默认为公有抽象成员
            function __addOuterAbstract() {
                if (that.prop.Abstract) {
                    that.P_addAbstract(that.prop.Abstract);
                }
            };
            function __addOuterVirtual() {
                if (that.prop.Virtual) {
                    that.P_addVirtualAndCheck(that.prop.Virtual);
                }
            };
        };

        AClass.prototype = new Structure();

        //创建普通类
        //父类_parent可以为{Class: xx, Interface: xx}，或者直接为xx类
        function Class() {
            var that = this;

            this.implementaionMap = {};
            this.parentClass = null;
            this.interface = null;
            this.prop = null;

            this.P_class = F;
            //当前是否处于创建类的阶段。
            this.initializing = false;


            // 创建的类（构造函数）
            function F() {
                var self = this,
                    args = arguments;

                function _restorePrototype() {
                    extendDeep(F.prototype, self);
                };
                function _init() {
                    // 如果当前处于实例化类的阶段，则调用构造函数Init
                    if (!that.initializing) {
                        self.Init && self.Init.apply(self, args);
                    }
                };

                _restorePrototype();
                _init();

                /*不能删除私有成员和保护成员！否则类的成员就不能调用到私有和保护的成员了（因为已经删除了）！
                 对象的创建算法参考http://www.cnblogs.com/TomXu/archive/2012/02/06/2330609.html




                 //删除私有成员和保护成员，这样外界就不能访问私有和保护成员了！
                 for (name in this) {
                 if (name.search(/(^_)|(^P_)/) !== -1) {
                 delete F.prototype[name];
                 //                                                    this[name] = null;
                 }

                 }
                 */
            }

            function __getByParent(args) {
                var _parent = args[0],
                    _prop = args[1];

                __checkOnlyOneParentClass(args);

                if (_prop === undefined) {
                    that.prop = _parent;
                    that.parentClass = null;
                    that.interface = null;
                }
                //{Class: xx, Interface: xx}
                else if (typeof _parent === "object") {
                    if (!_parent.Class && !_parent.Interface) {
                        throw new Error("Please add Class or Interface!");
                    }
                    that.parentClass = _parent.Class;
                    if (isArray(_parent.Interface)) {
                        that.interface = _parent.Interface;
                    }
                    else if (typeof _parent.Interface === "function") {
                        that.interface = [_parent.Interface];
                    }
                    that.prop = _prop;
                }
                //直接为xx类
                else if (typeof _parent === "function") {
                    that.parentClass = _parent;
                    that.interface = null;
                    that.prop = _prop;
                }
                else {
                    throw new Error("arguments is not allowed!");
                }
            };
            function __checkOnlyOneParentClass(args) {
                if (args.length >= 3) {
                    throw new Error("class can only inherit from one parentClass");
                }

                if (args[0].Class) {
                    if (isArray(args[0].Class) && args[0].Class.length >= 2) {
                        throw new Error("class can only inherit from one parentClass");
                    }
                }
            };
            this.P_addSpecial = function (moduleName, name) {
                if (name === "Abstract") {
                    throw new Error("class can't have abstract members");
                }
                if (name === "Virtual") {
                    this.P_addVirtualAndCheck(this.prop[moduleName][name]);
                    return "continue";
                }
                return null;
            };
            this.buildClass = function (args) {
                __getByParent(args);

                if (this.parentClass) {
                    this.initializing = true;
                    this.P_inherit();
                    this.initializing = false;
                }

                this.P_addInit();
                this.P_addPrivateMember();
                this.P_addProtectedMember();
                this.P_addPublicMember();
                this.P_addStaticMember();
                __addOuterAbstract();
                __addOuterVirtual();

                this.P_prepareCheck();
                this.P_checkImplementationOfAbstract();
                __checkEachImplementationOfInterface();

                return F;
            };
            function __checkEachImplementationOfInterface() {
                if (that.interface) {
                    var i = 0,
                        len = 0;

                    for (i = 0, len = that.interface.length; i < len; i++) {
                        that.P_checkImplementationOfInterface(that.interface[i]);
                    }
                }
                if (__hasInterfaceInheritFromParentClass()) {
                    that.P_checkImplementationOfInterface(that.parentClass);
                }
            };
            function __hasInterfaceInheritFromParentClass() {
                var name = "";

                for (name in F.prototype) {
                    if (F.prototype.hasOwnProperty(name)) {
                        if (name.contain("Interface_")) {
                            return true;
                        }
                    }
                }

                return false;
            };
            function __addOuterAbstract() {
                if (that.prop.Abstract) {
                    throw new Error("class can't have abstract members!");
                }
            };
            function __addOuterVirtual() {
                if (that.prop.Virtual) {
                    that.P_addVirtualAndCheck(that.prop.Virtual);
                }
            };
        };

        Class.prototype = new Structure();

        /*
         下面的写法有问题！因为只有载入YOOP.js时，创建了AClass的实例。
         调用YYC.AClass时，只是引用该实例的buildAClass，而不会再创建AClass实例。
         也就是说，所有YYC.AClass都共用一个AClass的实例！共用AClass实例的属性（如parent等）！

         YYC.AClass = new AClass().buildAClass;
         */


        YYC.AClass = function () {
            return new AClass().buildAClass(arguments);
        };
        YYC.Class = function () {
            return new Class().buildClass(arguments);
        };
    }());
}());

总结

我花了5天的时间来对YOOP进行重构，这样效率其实是比较低下的。我们应该采用TDD开发，在需要重构的时候立马重构。

因为随着人们对问题研究的深入，人们对问题的了解也越来越多，所以需要及时的反馈修正，对之前做的设计或代码进行修改，然后运行测试，保证测试的通过，然后再进行下一步的研究。这是一个迭代的过程，每次重构，都能反映自己的最新的理解。

为了保证代码质量，为了便于二次开发扩展，为了增强可读性，为了反映自己最新的理解，为了追求代码之美、设计之美，都需要我们在坚实的测试套件下，不断地重构改进。

需要注意的是，不仅是产品代码需要重构，测试代码也一样需要重构。

对于我们个人的修炼而言，应该时刻地重构；对于工程方面而言，有时为了赶进度，会对质量方面要求降低。但是作为程序员，应该对自己编写的代码负责，在赶进度的情况下，我们应该在项目结束或相对轻松的时间里，对代码进行重构，而且可以进行抽象、封装，提炼出自己的产品和文档。

只有通过不断地改进、总结，我们才能不断地进步。