快捷導(dǎo)航

JS Pro-深入面向?qū)ο蟮某绦蛟O(shè)計(jì)之繼承的詳解

更新時(shí)間：2013年05月07日 17:00:25 作者：

一般的面向?qū)ο蟪绦蛘Z言，有兩種繼承方法——接口繼承（interface inheritance）和實(shí)現(xiàn)繼承（implementation inheritance）。接口繼承只繼承方法簽名，而實(shí)現(xiàn)繼承則繼承實(shí)際的方法。在JavaScript中，函數(shù)沒有簽名，所以在JavaScript只支持實(shí)現(xiàn)繼承，而且主要是依靠原型鏈（prototype chaining）來是實(shí)現(xiàn)的

原型鏈(prototype chaining)：

利用原型來繼承屬性和方法?；仡櫼幌聵?gòu)造函數(shù)（constructor），原型對(duì)象（prototype）和實(shí)例（instance）的關(guān)系。每一個(gè)構(gòu)造函數(shù)都有一個(gè)prototype屬性，該屬性指向一個(gè)prototype對(duì)象；prototype對(duì)象也有constructor屬性，指向該函數(shù)；而實(shí)例也有一個(gè)內(nèi)部指針(__proto__)指向這個(gè)prototype對(duì)象。如果這個(gè)prototype對(duì)象是另外一個(gè)對(duì)象的實(shí)例會(huì)是怎樣的呢？這樣該prototype對(duì)象就包含一個(gè)指向另一個(gè)類型的指針，相應(yīng)地，另一個(gè)原型中也包含著一個(gè)指向另一個(gè)構(gòu)造函數(shù)的指針。

JS的繼承很簡(jiǎn)單，就是把子類的prototype設(shè)為父類的一個(gè)（實(shí)例化）對(duì)象

復(fù)制代碼代碼如下:

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

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

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

//inherit from SuperType
SubType.prototype = new SuperType();

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

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

最終的結(jié)果：instance的__proto__指向SubType.prototype對(duì)象，而SubType.prototype對(duì)象的__proto__屬性又指向SuperType.prototype對(duì)象。getSuperValue()是一個(gè)方法，所以仍然存在于原型中，而property是一個(gè)實(shí)例屬性，所以現(xiàn)在存在于SubType.prototype這個(gè)實(shí)例中。 instance.constructor現(xiàn)在指向的是SuperType，這是由于SubType.prototype指向SuperType.prototype，而SuperType.prototype的constructor屬性指向SuperType函數(shù)，所以instance.constructor指向SuperType。

默認(rèn)情況下，所有引用類型都繼承Object。這是因?yàn)樗泻瘮?shù)的原型對(duì)象，默認(rèn)都是Object的一個(gè)實(shí)例，所以內(nèi)部prototype(__proto__)指向Object.Prototype。

原型和實(shí)例的關(guān)系：可以使用2種方法來確定原型與實(shí)例之間的關(guān)系。
- instancef操作符：使用該操作符來測(cè)試實(shí)例與原型鏈中出現(xiàn)過的構(gòu)造函數(shù)，都會(huì)返回true

復(fù)制代碼代碼如下:

alert(instance instanceof Object); //true
alert(instance instanceof SuperType); //true
alert(instance instanceof SubType); //true

- isPrototypeOf()方法：只要是原型鏈中出現(xiàn)過的原型，都可以說是該原型鏈所派生的實(shí)例的原型。

復(fù)制代碼代碼如下:

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

給子類添加方法的注意點(diǎn)：我們有的時(shí)候會(huì)給子類添加方法，或者是重寫父類的某些方法。這個(gè)時(shí)候就要注意，這些方法必須在繼承后再定義。以下的例子里，SubType在繼承SuperType后，我們給它添加了新的方法getSubValue()，而且重寫了getSuperValue()方法。對(duì)于后者，只有SubType的實(shí)例才會(huì)使用重寫的方法，SuperType的實(shí)例還是會(huì)使用原有的getSuperValue()方法。

復(fù)制代碼代碼如下:

function SuperType(){
　　this.property = true;
}
SuperType.prototype.getSuperValue = function(){
　　return this.property;
};
function SubType(){
　　t　his.subproperty = false;
}
//inherit from SuperType
SubType.prototype = new SuperType();
//new method
SubType.prototype.getSubValue = function (){
　　return this.subproperty;
};
//override existing method
SubType.prototype.getSuperValue = function (){
　　return false;
};
var instance = new SubType();
alert(instance.getSuperValue()); //false

另外一個(gè)需要注意的是，通過原型鏈實(shí)現(xiàn)繼承時(shí)，不能使用對(duì)象字面量創(chuàng)建原型方法，因?yàn)檫@樣會(huì)重寫原型鏈。如下面的代碼，在SubType繼承SuperType以后，使用對(duì)象字面量給原型添加方法，但這樣做，會(huì)重寫SubType原型，重寫后的SubType.prototype包含的是一個(gè)Object的實(shí)例，從而也切斷了與SuperType的關(guān)系。

復(fù)制代碼代碼如下:

function SuperType(){
　　this.property = true;
}
SuperType.prototype.getSuperValue = function(){
　　return this.property;
};
function SubType(){
　　this.subproperty = false;
}
//inherit from SuperType
SubType.prototype = new SuperType();
//try to add new methods - this nullifies the previous line
SubType.prototype = {
　　getSubValue : function (){
　　　　return this.subproperty;
　　},
　　someOtherMethod : function (){
　　　　return false;
　　}
};
var instance = new SubType();
alert(instance.getSuperValue()); //error!

原型鏈的問題：和原型一樣，當(dāng)使用引用類型值的時(shí)候，原型鏈就會(huì)出問題了?；仡櫼幌轮暗膬?nèi)容，包含一個(gè)引用類型值的原型屬性會(huì)被所有實(shí)例共享，這就是為什么我們要把引用類型值在構(gòu)造函數(shù)中定義，而不是在原型中定義。在通過原型鏈實(shí)現(xiàn)繼承時(shí)，原型實(shí)際上會(huì)變成另一個(gè)類型的實(shí)例，于是，原先的實(shí)例屬性也順利成章的變成現(xiàn)在的原型屬性了。

復(fù)制代碼代碼如下:

function SuperType(){
　　this.colors = [“red”, “blue”, “green”];
}
function SubType(){
}
//inherit from 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”

在SuperType構(gòu)造函數(shù)中，我們定義了一個(gè)colors數(shù)組，每一個(gè)SuperType實(shí)例都會(huì)擁有它自己的這個(gè)colors數(shù)組。但是當(dāng)SubType使用原型鏈繼承SuperType以后，SubType.prototype變成SuperType的一個(gè)實(shí)例，因此它擁有自己的colors屬性，也就是說SubType.prototype.colors屬性。所以，當(dāng)創(chuàng)建SubType實(shí)例的時(shí)候，所有實(shí)例都共享這一屬性了。如上面的代碼所示。

第二個(gè)問題就是：在創(chuàng)建子類的實(shí)例時(shí)，不能向超類的構(gòu)造函數(shù)中傳遞參數(shù)。實(shí)際上，應(yīng)該說是沒有辦法在不影響所有對(duì)象實(shí)例的情況下，給超類的構(gòu)造函數(shù)傳遞參數(shù)。由于這些問題，我們不會(huì)單獨(dú)使用原型鏈。

--------------------------------------------------------------------------------

借用構(gòu)造函數(shù)(Contructor stealing)：
為了解決上述問題，開發(fā)人員發(fā)明了一種叫做借用構(gòu)造函數(shù)的技術(shù)。這種技術(shù)的思路就是：在子類型構(gòu)造函數(shù)的內(nèi)部調(diào)用超類型構(gòu)造函數(shù)。（函數(shù)，只不過是在特定環(huán)境中執(zhí)行代碼的對(duì)象？）我們可以通過使用apply()或call()方法在新創(chuàng)建的對(duì)象上執(zhí)行構(gòu)造函數(shù)。

復(fù)制代碼代碼如下:

function SuperType(){
　　this.colors = [“red”, “blue”, “green”];
}
function SubType(){
　　//inherit from 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”

我們?cè)赟ubType里使用call()方法調(diào)用SuperType的構(gòu)造函數(shù)，實(shí)際上就是在新的SubType對(duì)象上執(zhí)行SuperType()函數(shù)中定義的所有對(duì)象初始化代碼。結(jié)果就是每個(gè)SubType實(shí)例都具有自己的colors屬性的副本。

傳遞參數(shù)：使用借用構(gòu)造函數(shù)方法的一個(gè)很大的好處在于就是，我們可以從子類的構(gòu)造函數(shù)傳遞參數(shù)到父類的構(gòu)造函數(shù)中。

復(fù)制代碼代碼如下:

function SuperType(name){
　　this.name = name;
}
function SubType(){
　　//inherit from SuperType passing in an argument
　　SuperType.call(this, “Nicholas”);
　　//instance property
　　this.age = 29;
}
var instance = new SubType();
alert(instance.name); //”Nicholas”;
alert(instance.age); //29

新的SuperType構(gòu)造函數(shù)新增了一個(gè)參數(shù)name，我們?cè)赾all SuperType的同時(shí)，往SuperType傳遞參數(shù)"Nicholas"。為了不讓超類型的構(gòu)造函數(shù)重寫子類型的屬性，可以在調(diào)用超類型構(gòu)造函數(shù)后再定義子類的屬性。

借用構(gòu)造函數(shù)的問題：方法都在構(gòu)造函數(shù)中定義，無法復(fù)用。而且在超類型的原型中定義的方法，對(duì)子類型而言是不可見的。結(jié)果所有類型都只能使用構(gòu)造函數(shù)模式。

--------------------------------------------------------------------------------

組合繼承：
結(jié)合原型鏈及借用構(gòu)造函數(shù)各自的優(yōu)點(diǎn)的一種繼承模式。使用原型鏈繼承原型屬性及方法，使用借用構(gòu)造函數(shù)來繼承實(shí)例屬性。如下面例子，我們使用call()方法調(diào)用SuperType的構(gòu)造函數(shù)（每個(gè)SubType實(shí)例都擁有自己的name和colors屬性，以及SubType的age屬性）；然后再把SuperType實(shí)例賦值給SubType的原型，使其繼承SuperType的sayName()方法（每個(gè)實(shí)例都共用這個(gè)方法）。

復(fù)制代碼代碼如下:

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

SuperType.prototype.sayName = function(){
alert(this.name);
};

function SubType(name, age){
    //inherit properties
    SuperType.call(this, name);
    this.age = age;
}
//inherit methods
SubType.prototype = new SuperType();
SubType.prototype.sayAge = function(){
    alert(this.age);
};

var instance1 = new SubType("Nicholas", 29);
instance1.colors.push("black");
alert(instance1.colors); //"red,blue,green,black"
instance1.sayName(); //"Nicholas";
instance1.sayAge(); //29
var instance2 = new SubType("Greg", 27);
alert(instance2.colors); //"red,blue,green"
instance2.sayName(); //"Greg";
instance2.sayAge(); //27

原型式繼承(Prototypal Inheritance)：

復(fù)制代碼代碼如下:

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

寄生式繼承(Parasitic Inheritance)：

缺點(diǎn)同構(gòu)造函數(shù)

您可能感興趣的文章: