李战《悟透JavaScript》精彩代码节选(继承）-优快云博客

本文链接：https://blog.youkuaiyun.com/iteye_20481/article/details/82135684
本文介绍了一种使用JavaScript实现面向对象编程的方法，通过自定义构造函数和原型链实现了类的继承和多态特性。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
        <title>李战《悟透JavaScript》 精彩代码节选</title>
    </head>
    <body>
        <script type ='text/javascript'>
            function Class(){
                var aDefine = arguments[arguments.length - 1];//最后一个参数是类定义
                if (!aDefine) 
                    return;
                //基类为自定义的object或者是第一个参数的类
                var aBase = arguments.length > 1 ? arguments[0] : object; //解析基类
                function prototype_(){
                };//构造prototype的临时函数，用于挂接原型链
                prototype_.prototype = aBase.prototype;


                var aPrototype = new prototype_();

                //复制类定义到aPrototype,后面以它为原型对象
                for (var member in aDefine) {
                    //构造函数不用复制
                    if (member != "Create") {
                        aPrototype[member] = aDefine[member];
                    }
                }

                //根据是否继承特殊属性和性能情况，可分别注释掉下列的语句
                if (aDefine.toString != Object.prototype.toString) 
                    aPrototype.toString = aDefine.toString;
                if (aDefine.toLocaleString != Object.prototype.toLocaleString) 
                    aPrototype.toLocaleString = aDefine.toLocaleString;
                if (aDefine.valueOf != Object.prototype.valueOf) 
                    aPrototype.valueOf = aDefine.valueOf;

                if (aDefine.Create) {
                    //调用本身的构造函数，自定义为Create（注意它是一个函数，并没被执行）
                    var aType = aDefine.Create;
                }
                else {
                    //本例中好像没用到
                    aType = function(){
                        this.base.apply(this, arguments);
                    };
                }
                //aType并不是实例化的对象，而是自定义的构造函数（虽然函数也是对象）
                aType.prototype = aPrototype;
                //设置类型关系，便于追溯继承关系
                aType.Base = aBase;
                //为本类对象扩展一个Type属性，主要是为了作类型识别，实现instanceof
                aType.prototype.Type = aType;
                //返回构造函数作为类
                return aType;
            };

            //根类object定义，主要是给那些没有显式定义基类的使用
            function object(){
            };

            //判断对象是否属于某类型，类似于instanceof
            object.prototype.isA = function(aType){
                var self = this.Type;
                while (self) {
                    if (self == aType) {
                        return true;
                    }
                    self = self.Base;
                };
                return false;
            };

            //调用基类构造函数
            //这个版本主要是为了兼容不支持caller属性的Opera浏览器
            object.prototype.base = function(){
                //获取当前对象的基类
                var Base = this.Type.Base;
                //若基类己没有基类
                if (!Base.Base) {
                    //则直接调用基类构造函数
                    Base.apply(this, arguments);
                }
                else {
                    //先覆写this.base
                    this.base = MakeBase(Base);
                    //再调用基类构造函数
                    Base.apply(this, arguments);
                    //删除覆写的base属性
                    delete this.base;
                };

                function MakeBase(Type){
                    var Base = Type.Base;
                    if (!Base.Base) 
                        return Base;

                    return function(){
                        this.base = MakeBase(Base);
                        Base.apply(this, arguments);
                    };
                };
                }


            //不支持Opera
            object.prototype.base = function(){
                var Caller = object.prototype.base.caller;
                Caller && Caller.Base && Caller.Base.apply(this, arguments);

            }



            //应用效果
            var Person = Class({
                Create: function(name, age){
                    this.base();
                    this.name = name;
                    this.age = age;
                },
                SayHello: function(){
                    alert("Hello,I'm " + this.name + ", " + this.age + "years old.");
                },
                toString: function(){
                    return this.name;
                }

            });
            var Employee = Class(Person, {
                Create: function(name, age, salary){
                    this.base(name, age);
                    this.salary = salary;
                },
                ShowMeTheMoney: function(){
                    alert(this + "$" + this.salary);
                }
            });

            var BillGates = new Person("Bill Gates", 53);
            var SteveJobs = new Employee("Steve Jobs", 53, 1234);
            alert(BillGates);
            BillGates.SayHello();
            SteveJobs.SayHello();
            SteveJobs.ShowMeTheMoney();

            //用BillGates的类型建LittleBill
            var LittleBill = new BillGates.Type("Little Bill", 6);
            LittleBill.SayHello();

            alert(BillGates.isA(Person));
            alert(BillGates.isA(Employee));
            alert(SteveJobs.isA(Person));
        </script>
    </body>
</html>