高程6.3继承

许多OO语言都支持两种继承方式:接口继承和实现继承.接口继承只继承方法签名,而实现继承则继承实际的方法.由于函数没有签名,在ECMAScript中无法实现接口继承,只支持实现继承,而且主要依靠原型链来实现继承.

6.3.1 原型链

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

构造函数,原型和实例的关系:每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针,而实例都包含一个指向原型对象的内部指针.如果我们让原型对象等于另一个类型的实例,那么原型对象将包含一个指向另一个原型的指针,相应地,另一个原型中也包含着一个指向另一个构造函数的指针.如此层层递进,就构造了实例与原型的链条.这就是所谓原型链的基本概念.

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

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

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

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

    var instance=new SubType();
    console.log(instance.getSuperValue());//true

SubType继承了SuperType,而继承是通过创建SuperType的实例,并将该实例赋给SubType.prototype实现的.实现的本质是重写原型对象,代之以一个新类型的实例.

getSuperValue()方法仍然还在SuperType.prototype中,但property则位于SubType.prototype中.这是因为property是一个实例属性,而getSuperValue()则是一个原型方法.既然SubType.prototype现在是SuperType的实例,那么property就位于该实例中了.要注意instance.constructor现在指向的是SuperType,这是因为原来SubType.prototype中的constructor被重写了的缘故.

上面例子中,调用instance.getSuperValue()会经历三个搜索步骤:1)搜索实例,2)搜索SubType.prototype;3)搜索SuperType.prototype,最后一步才会找到该方法.

1.别忘记默认的原型

所有函数的默认原型都是Object的实例,因此默认原型都会包含一个内部指针,指向Object.prototype.这也是所有自定义类型都会继承toString(),valueOf()等默认方法的根本原因.下面是上面例子的完整原型链.

SubType继承了SuperType,而SuperType继承了Object.当调用instance.toString()时,实际上调用的是保存在Object.prototype中的那个方法.

2.确定原型和实例的关系

可以通过两种方法来确定原型和实例的关系.

第一种是使用instanceof操作符,只要用这个操作符来测试实例与原型链中出现过的构造函数,结果就会返回true.

console.log(instance instanceof Object);//true
    console.log(instance instanceof SuperType);//true
    console.log(instance instanceof SubType);//true

第二种是使用isPrototypeof()方法.同样,只要是原型链中出现过的原型,都可以说是该原型链派生的实例的原型,因此isPrototypeof()方法也会返回true;

console.log(Object.prototype.isPrototypeOf(instance));//true
    console.log(SuperType.prototype.isPrototypeOf(instance));//true
    console.log(SubType.prototype.isPrototypeOf(instance));//true

3.谨慎地定义方法

给原型添加方法的代码一定要放在替换原型的语句之后.

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

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

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

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

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

getSuperValue()是原型链中已经存在的一个方法,重写这个方法将人屏蔽原来的那个方法.当通过SubType的实例调用getSuperValue()时,调用的就是这个重新定义的方法;但通过SuperType的实例调用getSuperValue()时,还会继续调用原来那个方法.

必须在用SuperType的实例替换原型之后,再定义两个方法.

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

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

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

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

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

    var instance=new SubType();
    console.log(instance.getSuperValue());//Uncaught TypeError: instance.getSuperValue is not a function

由于现在的原型包含的是一个Object的实例,而非SuperType的实例,因此我们设想中的原型链已经被切断---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");
    console.log(instance1.colors);//["red", "blue", "green", "black"]

    var instance2=new SubType();
    console.log(instance2.colors);//["red", "blue", "green", "black"]

我们对instance1.colors的修改能够通过instance2.colors反映出来.

原型链的第二个问题是:在创建子类型的实例时,不能像超类型的构造函数中传递参数.实际上,应该说是没有办法在不影响所有对象实例的情况下,给超类型的构造函数传递参数.

实践中很少会单独使用原型链.

6.3.2 借用构造函数

借用构造函数(constructor stealing),这种技术的基本思想相当简单,即在子类型构造函数的内部调用超类型构造函数.函数只不过是特定环境中执行代码的对象,因此通过使用apply()和call()方法也可以在(将来)新创建的对象上执行构造函数.

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

    function SubType(){
        //继承了SuperType
        SuperType.call(this);
    }

    var instance1=new SubType();
    instance1.colors.push("black");
    console.log(instance1.colors);//["red", "blue", "green", "black"]

    var instance2=new SubType();
    console.log(instance2.colors);//["red", "blue", "green"]

1.传递参数

相对原型链,借用构造函数可以在子类型构造函数中向超类型构造函数传递参数.

function SuperType(name){
        this.name=name;
    }
    function SubType(){
        //继承了SuperType,同时还传递了参数
        SuperType.call(this,"Nicholas");

        //实例属性
        this.age=29;
    }

    var instance=new SubType();
    console.log(instance.name);//Nicholas
    console.log(instance.age);//29

2.借用构造函数的问题

如果仅仅是借用构造函数,那么也存在问题---方法都在构造函数中定义,因此函数利用就无从谈起了.而且,在超类型的原型中定义的方法,对子类型而言也是不可见的,结果所有类型都只能借用构造函数模式.

6.3.3 组合继承

组合继承(combination inheritance),有时候也叫做伪经典继承,指的是将原型链和借用构造函数的技术组合到一块,从而发挥二者之长的一种继承模式.其背后的思路是使用原型链实现对原型属性和方法的继承,而通过借用构造函数来实现对实例属性的继承.这样,既通过在原型上定义方法实现了函数复用,又能够保证每个实例都有它自己的属性.

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

    SuperType.prototype.sayName=function(){
        console.log(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(){
        console.log(this.age);
    }

    var instance1=new SubType("Nicholas",29);
    instance1.colors.push("black");
    console.log(instance1.colors);//["red", "blue", "green", "black"]
    instance1.sayName();//Nicholas
    instance1.sayAge();//29

    var instance2=new SubType("Greg",27);
    console.log(instance2.colors);//["red", "blue", "green"]
    instance2.sayName();//Greg
    instance2.sayAge();//27

组合继承避免了原型链和借用构造函数缺陷,融合了它们的优点,成为JavaScript中最常用的继承模式.而且,instanceof和isPrototypeOf()也能够用于识别基于组合继承创建的对象.

6.3.4原型式继承

ECMAScript 5通过新增Object.create()方法规范化了原型式继承.这个方法接收两个参数:一个用作新对象原型的对象和(可选的)一个为新对象定义额外属性的对象.在传入一个参数的情况下,Object.create()与object()方法的行为相同.

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

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

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

    console.log(person.friends);//["Shelby", "Court", "Van", "Rob", "Barbie"]

Object.create()方法的第二个参数与Object.defineProperties()方法的第二个参数格式相同:每个属性都是通过自己的描述符定义的.以这种方式指定的任何属性都会覆盖原型对象上的同名属性.

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

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

    console.log(anotherPerson.name);//Greg

6.3.5 寄生式继承

组合继承是JavaScript最常用的继承模式;不过,它也有自己的不足.组合继承最大的问题就是无论什么情况下,都会调用两次超类型构造函数:一次是在创建子类型原型的时候,另一次是在子类型构造函数内部.没错,子类型最终会包含超类型对象的全部实例属性,但我们不得不在调用了类型构造函数时重写这些属性.

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

    SuperType.prototype.sayName=function(){
        console.log(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(){
        console.log(this.age);
    }

所谓寄生组合继承,即通过借用构造函数来继承属性,通过原型链的混成形式来继承方法.其背后的思路是:不必为了指定子类型的原型而调用超类型的构造函数,我们所需要的无非就是超类型原型的一个副本而已.本质上,就是使用寄生式继承来继承超类型的原型,然后再将结果指定给子类型的原型.

寄生组合式继承的基本模式如下所示:

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

这个示例中的inheritPrototype()函数实现了寄生组合式继承的最简单形式.这个函数接收两个参数:子类型构造函数和超类型构造函数.在函数内部,第一步是创建超类型原型的一个副本.第二步是为创建的副本添加constructor属性,从而弥补因重写原型而失去的默认的constructor属性.最后一步,将新创建的对象(即副本)赋值给子类型的原型.这样,我们就可以用调用inheritPrototype()函数的语句,去替换前面例子中为子类型原型赋值的语句了.

开发人员普通认为寄生组合式继承是引用类型最理想的继承范式.

6.4 小结

ECMAScript支持面向对象(OO)编程,但不使用类型或者接口.对象可以在代码执行过程中创建和增强,因此具有动态性而非严格定义的实体.在没有类的情况下,可以采用下列模式创建对象.

工厂模式,使用简单的函数创建对象,为对象添加属性和方法,然后返回对象.这个模式后来被构造函数模式所取代.

构造函数模式,可以创建自定义引用类型,可以像创建内置对象实例一样使用new操作符.不过,构造函数模式也有缺点,即它的每个成员都无法得到复用,包括函数.由于函数可以不局限于任何对象(即与对象具有松散耦合的特点),因此没有理由不在多个对象间共享函数.

原型模式,使用构造函数的prototype属性来指定那些应该共享的属性和方法.组合使用构造函数模式和原型模式时,使用构造函数定义实例属性,而使用原型定义共享的属性和方法.

JavaScript主要通过原型链实现继承.原型链的构造是通过将一个类型的实例幅值给另一个构造函数的原型实现的.这样,子类型就能够访问超类型的所有属性和方法,这一点与基本类的继承很相似.原型链的问题是对象实便共享所有继承的属性和方法,因此不适宜单独使用.解决这个问题的技术是借用构造函数,同时还能保证只使用构造函数模式来定义类型.使用最多的继承模式是组合继承,这种模式使用原型链继承共享的属性和方法,而通过借用构造函数继承实例属性.

此外,还存在下列可供选择的继承模式.

原型式继承,可以在不必预先定义构造函数的情况下实例继承,其本质是执行对给定对象的浅复制.而复制得到的副本还可以得到进一步改造.

寄生式继承,与原型式继承非常相似,也是基本某个对象或某些信息创建一个对象,然后增强对象,最后返回对象.为了解决组合继承模式由于多次调用超类型构造函数而导致的低效率问题,可以将这个模式与组合继承一起使用.

寄生组合式继承,集寄生式继承和组合继承的优点与一身,是实现基于类型继承的最有效方式.