javascript對象繼承詳解

問題

好比咱們有一個「動物」對象的構造函數。

function animal() {
        this.type = '動物';
    }

還有一個「貓」對象的構造函數。

function cat(name,color) {
        this.name = name;
        this.color = color;
    }

咱們知道貓也屬於動物，若是這個貓對象想要繼承動物對象的屬性，咱們該怎麼作呢？

構造函數綁定

使用構造函數綁定是最簡單的方法，使用call或者apply將父對象綁定在自對象上就能夠了。

function cat(name,color) {
        animal.apply(this,arguments);
        this.name = name;
        this.color = color;
    }
    var cat1 = new cat("haha", 'red');
    console.log(cat1.type);  //動物

不過這種方法比較少見。

拷貝繼承

若是把父對象的全部屬性和方法，拷貝進子對象，也能夠實現繼承。

function extend(Child, Parent) {
　　　　var p = Parent.prototype;
　　　　var c = Child.prototype;
　　　　for (var i in p) {
　　　　　　c[i] = p[i];
　　　　　　}
　　　　c.uber = p;     //橋樑做用
　　}

使用方法：

extend(cat, animal);
    var cat1 = new cat("haha","red");
    alert(cat1.type);     // 動物

原型繼承（prototype）

相比於上面的直接綁定，原型繼承的方法比較常見，對於prototype，我本身簡單總結了一下。

每一個函數都有一個prototype屬性，這個屬性是指向一個對象的引用，當使用new關鍵字建立新實例的時候，這個實例對象會從原型對象上繼承屬性和方法。

也就是說，若是將「貓」構造函數的prototype屬性指向一個「動物」實例，那麼再建立「貓」對象實例的時候，就繼承了「動物」對象的屬性和方法了。

繼承實例

cat.prototype = new animal();
    cat.prototype.constructor = cat;
    var cat1 = new cat("haha","red");
    console.log(cat1.constructor == cat);   //true
    console.log(cat1.type);  // 動物

• 代碼第一行，咱們將cat函數的prototype對象指向一個animal對象的實例（其中就包含了animal的type屬性了）。

• 代碼第二行是什麼意思呢？

  • 首先，假如咱們沒有加這行代碼，運行

    cat.prototype = new animal();
        console.log(cat.prototype.constructor == animal);  //true

    也就是說，其實每一個prototype對象都有一個constructor屬性，指向它的構造函數。

  • 咱們再看下面的代碼

    cat.prototype = new animal();
        var cat1 = new cat("haha", 'red');
        console.log(cat1.constructor == animal);   //true

    由上咱們看到實例cat1的構造函數是animal，因此，顯然是不對的。。。cat1明明是new cat()才生成的，因此咱們應該手動糾正。cat.prototype對象的constructor值改成cat。

  • 因此這也是咱們應該注意的一點，若是咱們替換了prototype對象，就應該手動糾正prototype對象的constructor屬性。

    o.prototype = {};
        o.prototype.constructor = o;

直接繼承prototype

因爲在animal對象中，不變的屬性能夠直接寫在animal.prototype中。而後直接讓cat.prototype指向animal.prototype也就實現了繼承。

如今咱們先將animal對象改寫成:

function animal() {
    }
    animal.prototype.type = '動物';

而後再實現繼承:

cat.prototype = animal.prototype;
    cat.prototype.constructor = cat;
    var cat1 = new cat("haha","red");
    console.log(cat1.type); // 動物

與上一種方法相比，這種方法顯得效率更高（沒有建立animal實例），節省了空間。可是這樣作正確嗎？答案是不正確，咱們繼續看。

cat.prototype = animal.prototype;

這行代碼讓cat.prototype和animal.prototype指向了同一個對象，因此若是改變了cat.prototype的某一個屬性，都會反映到animal.prototype上，這顯然不是咱們想要看到的。

好比咱們運行：

console.log(animal.prototype.constructor == animal)  //false

結果看到是false，爲何呢？cat.prototype.constructor = cat;這一行就會把animal.prototype的constructor屬性也改掉了。

利用空對象做爲中介

var F = function(){};
    F.prototype = animal.prototype;
    cat.prototype = new F();
    cat.prototype.constructor = cat;

結合上面兩種方法，由於F是空對象，因此幾乎不佔內存。這時修改cat的prototype對象，就不會影響到animal的prototype對象。

console.log(animal.prototype.constructor == animal);   // true

而後咱們將上面的方法封裝一下：

function extend(Child, Parent) {
　　　　var F = function(){};
　　　　F.prototype = Parent.prototype;
　　　　Child.prototype = new F();
　　　　Child.prototype.constructor = Child;
　　　　Child.uber = Parent.prototype;
　　}

使用的時候，方法以下：

extend(cat,animal);
    var cat1 = new cat("haha","red");
    console.log(cat1.type); // 動物

Child.uber = Parent.prototype; 這行代碼就是個橋樑做用，讓子對象的uber屬性直接指向父對象的prototype屬性，等於在自對象上打開一條叫uber的通道，讓子對象的實例可以使用父對象的全部屬性和方法。