JavaScript面向对象的程序设计——继承

ECMAScript支持实现继承,主要依赖于原型链来实现。

原型链

原型链的基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。

        function SuperType() {
            this.property = true;
        }

        SuperType.prototype.getSuperValue = function(){
            return this.property;
        };

        function SubType() {
            this.subproperty = false;
        }

        //继承了SuperType
        SubType.prototype = new SuperType();

        SubType.prototype.getSuperValue = function () {
            return this.subproperty;
        };

        var instance = new SubType();
        alert(instance.getSuperValue());//true
构造函数和原型之间的关系
  • 1.别忘记默认的原型
完整的原型链
  • 2.确定原型和实例的关系
    instanceof方法
        alert(instance instanceof Object);//true
        alert(instance instanceof SuperType);//true
        alert(instance instanceof SubType);//true

isPrototypeOf()方法

        alert(Object.prototype.isPrototypeOf(instance));//ture
        alert(SuperType.prototype.isPrototypeOf(instance));//ture
        alert(SubType.prototype.isPrototypeOf(instance));//ture
  • 3.谨慎的定义方法
    给原型添加方法的代码一定要放在替换原型的语句之后
        function SubType() {
            this.subproperty = false;
        }

        //继承了SuperType
        SubType.prototype = new SuperType();

        //添加新方法
        SubType.prototype.getSuperValue = function () {
            return this.subproperty;
        };

        //重写超类型中的方法
        SubType.prototype.getSuperValue = function () {
            return false;
        };

        var instance = new SubType();
        alert(instance.getSuperValue());//false

getSuperValue()是原型链中已经存在的一个方法,但重写这个方法将会屏蔽原来的那个方法。当通过SubType的实例调用getSuperValue()时,调用的就是这个重新定义的方法,但通过SuperType的实例调用getSuperValue()时,还会继续调用原来的那个方法。必须在 用SuperType的实例替换原型之后,再定义这两个方法。

在通过原型链实现继承时,不能使用对象字面量创建原型方法。因为这样会重写原型链。

        function SubType() {
            this.subproperty = false;
        }

        //继承了SuperType
        SubType.prototype = new SuperType();

        //使用字面量添加新方法,会导致上一行代码无效
        SubType.prototype = {
            getSubValue: function () {
                return this.subproperty;
            },

            someOtherMethod: function () {
                return false;
            }
        };

        var instance = new SubType();
        alert(instance.getSuperValue());//error

原型链已经被切断,SubType和SuperType之间已经没有关系。

  • 4.原型链的问题
    最主要的问题来自包含引用类型值的原型。
        function SuperType() {
            this.colors = ["red", "blue", "green"];
        }
        function SubType() {
        }
        //继承了SuperType
        SubType.prototype = new SuperType();

        var instance1 = new SubType();
        instance1.colors.push("black");
        alert(instance1.colors);//"red,blue,green,black"

        var instance2 = new SubType();
        alert(instance2.colors);//"red,blue,green,black"

原型链的第二个问题是:在创建子类型的是实例时,不能向超类型的构造函数传递参数。

借用构造函数

借用构造函数的基本思想是在子类型构造函数的内部调用超类型构造函数。函数是在特定环境中执行代码的对象,通过使用apply()和call()可以在(将来)新创建的对象上执行构造函数。

        function SuperType() {
            this.colors = ["red", "blue", "green"];
        }
        function SubType() {
            //继承了SuperType
            SuperType.call(this);
        }

        var instance1 = new SubType();
        instance1.colors.push("black");
        alert(instance1.colors);//"red,blue,green,black"

        var instance2 = new SubType();
        alert(instance2.colors);//"red,blue,green"

SubType的每个实例都具有自己的colors属性的副本。

  • 1.传递参数
    借用构造函数的一个很大的优势,是可以在子类型构造函数中向超类型构造函数传递参数。
function SuperType(name) {
            this. name = name;
        }
        function SubType() {
            //继承了SuperType,同时还传递了参数
            SuperType.call(this,"Icey");
            //实例属性
            this.age =25;
        }
        var instance = new SubType();
        alert(instance.name); //"Icey"
        alert(instance.age);//25

组合继承

使用原型链实现对原型属性和方法的继承,而通过借用构造函数实现对实例属性的继承。

    function SuperType(name) {
            this.name = name;
            this.colors = ["red", "blue", "green"];
        }

        SuperType.prototype.sayName = function () {
            alert(this.name);
        };
        function SubType(name, age) {
            //继承属性
            SuperType.call(this,name);
            this.age = age;
        }

        //继承方法
        SubType.prototype = new SuperType();
        SubType.prototype.constructor = SubType;
        SubType.prototype.sayAge = function () {
            alert(this.age);
        };

        var instance1 = new SubType("Icey",25);
        instance1.colors.push("black");
        alert(instance1.colors);//"red,blue,green,black"
        instance1.sayName();//:Icey
        instance1.sayAge();//25

        var instance2 = new SubType("Root",22);
        alert(instance2.colors);//"red,blue,green"
        instance2.sayName();//"Root"
        instance2.sayAge();//22

原型式继承

借组原型可以基于已有的对象创建新对象,同时还不必因此创建自定义类型。

        function object(o) {
            function F() {}
            F.prototype = o;
            return new F();
        }

object()对传入其中的对象执行了一次浅复制。

        var person = {
            name: "Icey",
            friends: ["Shelby", "Court", "Van"]
        };

        var anotherPerson = object(person);
        anotherPerson.name = "Root";
        anotherPerson.friends.push("Rob");

        var yetAnotherPerson = object(person);
        yetAnotherPerson.name = "Linda";
        yetAnotherPerson.friends.push("Barbie");

        alert(person.friends);//"Shelby,Court,Van,Rob,Barbie"

ECMAScript5通过新增Object.create()方法规范化原型式继承。这个方法接收两个参数:一个用作新对象原型的对象和(可选的)一个为新对象定义额外属性的对象。

        var person = {
            name: "Icey",
            friends: ["Shelby", "Court", "Van"]
        };

        var anotherPerson = Object.create(person);
        anotherPerson.name = "Root";
        anotherPerson.friends.push("Rob");

        var yetAnotherPerson = Object.create(person);
        yetAnotherPerson.name = "Linda";
        yetAnotherPerson.friends.push("Barbie");

        alert(person.friends);//"Shelby,Court,Van,Rob,Barbie"

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同:每个属性都是通过自己的描述符定义的。

   var person = {
            name: "Icey",
            friends: ["Shelby", "Court", "Van"]
        };

        var anotherPerson = Object.create(person,{
            name: {
                value: "Greg"
            }
        });
        alert(anotherPerson.name);//"Greg"

寄生式继承

创建一个仅用于封装继承过程的函数,该函数内部以某种方式来增强对象,最后再像真的是它做了所有工作一样返回对象。

        function createAnother(original) {
            var clone = object(original);//通过调用函数创建一个新对象
            clone.sayHi = function () {//以某种方式来增强这个对象
                alert("hi");
            };
            return clone; //返回这个对象
        }
        var person = {
            name: "Icey",
            friends: ["Shelby", "Court", "Van"]
        };

        var anotherPerson = createAnother(person);
        anotherPerson.sayHi();//"hi"

寄生组合式继承

组合继承的例子:

        function SuperType(name) {
            this.name = name;
            this.colors = ["red", "blue", "green"];
        }

        SuperType.prototype.sayName = function () {
            alert(this.name);
        };
        function SubType(name, age) {
            SuperType.call(this,name); //第二次调用SuperType()
            this.age = age;
        }


        SubType.prototype = new SuperType(); //第一次调用SuperType()
        SubType.prototype.constructor = SubType;
        SubType.prototype.sayAge = function () {
            alert(this.age);
        };

j
寄生组合继承,通过借用构造函数来继承属性,通过原型链继承方法。不必为了指定子类型的原型而调用超类型的构造函数。

        function inheritPrototype(subType,superType) {
            var prototype = object(superType.prototype);//创建对象
            prototype.constructor = subType;//增强对象
            subType.prototype = prototype; //指定对象
        }

第一步创建超类型原型的一个副本。第二步为创建的副本添加constructor属性,弥补因重写原型而失去的默认的constructor属性。最后,将新创建的对象(即副本)赋值给子类型的原型。

function SuperType(name) {
            this.name = name;
            this.colors = ["red", "blue", "green"];
        }

        SuperType.prototype.sayName = function () {
            alert(this.name);
        };
        function SubType(name, age) {
            SuperType.call(this,name); 
            this.age = age;
        }

        inheritPrototype(SubType,SuperType);
    
        SubType.prototype.sayAge = function () {
            alert(this.age);
        };
寄生组合式继承

它只调用了一次SuperType构造函数。

推荐阅读更多精彩内容