構造函數&繼承

一、javascript是一門面向對象語言，區別於一般的面嚮對象語言，屬於弱語言，定義的變量的類型可隨着所在環境而變化;
二、面嚮對象語言的特性都有：繼承，封裝，多態；
1、封裝：var Cat = {name : “’’,color :”’’}; // 一個對象裏封裝了兩個屬性；
2、多態：”+”運算符操作的對象類型不一樣時，結果也不一樣就是多態；
3、繼承：接下來講繼承。

一、 生成實例對象的原始模式
假定我們把貓看成一個對象，它有"名字"和"顏色"兩個屬性。

 var Cat = { name : '', color : ' }

現在，我們需要根據這個原型對象的規格（schema），生成兩個實例對象。

 var cat1 = {}; // 創建一個空對象
 cat1.name = "大毛"; // 按照原型對象的屬性賦值
 cat1.color = "黃色";
 var cat2 = {};
 cat2.name = "二毛";
 cat2.color = "黑色";

好了，這就是最簡單的封裝了，把兩個屬性封裝在一個對象裏面。但是，這樣的寫法有兩個缺點，一是如果多生成幾個實例，寫起來就非常麻煩；二是實例與原型之間，沒有任何辦法，可以看出有什麼聯繫。

二、原始模式的改進
我們可以寫一個函數，解決代碼重複的問題。

function Cat(name,color) {
   	reutrn { name: name, color: color }
}

然後生成實例對象，就等於是在調用函數：

 var cat1 = Cat("大毛","黃色");
 var cat2 = Cat("二毛","黑色");

這種方法的問題依然是，cat1和cat2之間沒有內在的聯繫，不能反映出它們是同一個原型對象的實例。

三、 構造函數模式
爲了解決從原型對象生成實例的問題，Javascript提供了一個構造函數（Constructor）模式。
所謂"構造函數"，其實就是一個普通函數，但是內部使用了this變量。對構造函數使用new運算符，就能生成實例，並且this變量會綁定在實例對象上。
比如，貓的原型對象現在可以這樣寫，

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

我們現在就可以生成實例對象了。

var cat1 = new Cat("大毛","黃色");
var cat2 = new Cat("二毛","黑色");
alert(cat1.name); // 大毛
alert(cat1.color); // 黃色

這時cat1和cat2會自動含有一個constructor屬性，指向它們的構造函數。

alert(cat1.constructor == Cat);//true
alert(cat2.constructor == Cat);//true

Javascript還提供了一個instanceof運算符，驗證原型對象與實例對象之間的關係。

alert(cat1 instanceof Cat);//true
alert(cat2 instanceof Cat);//true

四、構造函數模式的問題

構造函數方法很好用，但是存在一個浪費內存的問題。

請看，我們現在爲Cat對象添加一個不變的屬性type（種類），再添加一個方法eat（喫）。那麼，原型對象Cat就變成了下面這樣：

function Cat(name,color){

　this.name = name;

　this.color = color;

　this.type = "貓科動物";
　
　this.eat =function(){alert("喫老鼠");};
}

還是採用同樣的方法，生成實例：

var cat1 = new Cat("大毛","黃色");
var cat2 = new Cat ("二毛","黑色");
alert(cat1.type); // 貓科動物
cat1.eat(); // 喫老鼠

表面上好像沒什麼問題，但是實際上這樣做，有一個很大的弊端。那就是對於每一個實例對象，type屬性和eat()方法都是一模一樣的內容，

每一次生成一個實例，都必須爲重複的內容，多佔用一些內存。這樣既不環保，也缺乏效率。

alert(cat1.eat == cat2.eat);//false

能不能讓type屬性和eat()方法在內存中只生成一次，然後所有實例都指向那個內存地址呢？回答是可以的。

五、 Prototype模式

Javascript規定，每一個構造函數都有一個prototype屬性，指向另一個對象。這個對象的所有屬性和方法，都會被構造函數的實例繼承。

這意味着，我們可以把那些不變的屬性和方法，直接定義在prototype對象上。

function Cat(name,color){

　this.name = name;

	this.color = color;
}

Cat.prototype.type = "貓科動物";

Cat.prototype.eat =function(){alert("喫老鼠")};

然後，生成實例。

var cat1 = new Cat("大毛","黃色");

var cat2 = new Cat("二毛","黑色");

alert(cat1.type); // 貓科動物

cat1.eat(); // 喫老鼠

這時所有實例的type屬性和eat()方法，其實都是同一個內存地址，指向prototype對象，因此就提高了運行效率。

alert(cat1.eat == cat2.eat);//true

六、 Prototype模式的驗證方法

爲了配合prototype屬性，Javascript定義了一些輔助方法，幫助我們使用它。，

6.1 isPrototypeOf()

這個方法用來判斷，某個proptotype對象和某個實例之間的關係。

alert(Cat.prototype.isPrototypeOf(cat1));//true
alert(Cat.prototype.isPrototypeOf(cat2));//true

6.2 hasOwnProperty()

每個實例對象都有一個hasOwnProperty()方法，用來判斷某一個屬性到底是本地屬性，還是繼承自prototype對象的屬性。

alert(cat1.hasOwnProperty("name"));// true
alert(cat1.hasOwnProperty("type"));// false

構造函數的繼承

現在有一個"動物"對象的構造函數。

function Animal(){ this.species = "動物";}

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

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("大毛","黃色");

alert(cat1.species); // 動物

二、 prototype繼承

第二種方法更常見，使用prototype屬性。

如果"貓"的prototype對象，指向一個Animal的實例，那麼所有"貓"的實例，就能繼承Animal了。

Cat.prototype = new Animal();
Cat.prototype.constructor =Cat;
var cat1 = new Cat("大毛","黃色");
alert(cat1.species); // 動物

代碼的第一行，我們將Cat的prototype對象指向一個Animal的實例。

Cat.prototype = new Animal();

它相當於完全刪除了prototype 對象原先的值，然後賦予一個新值。但是，第二行又是什麼意思呢？

Cat.prototype.constructor =Cat;

原來，任何一個prototype對象都有一個constructor屬性，指向它的構造函數。如果沒有"Cat.prototype = newAnimal();"這一行，
Cat.prototype.constructor是指向Cat的；加了這一行以後，Cat.prototype.constructor指向Animal。

alert(Cat.prototype.constructor== Animal); //true

更重要的是，每一個實例也有一個constructor屬性，默認調用prototype對象的constructor屬性。

alert(cat1.constructor ==Cat.prototype.constructor); // true

因此，在運行"Cat.prototype = newAnimal();"這一行之後，cat1.constructor也指向Animal！

alert(cat1.constructor ==Animal); // true

這顯然會導致繼承鏈的紊亂（cat1明明是用構造函數Cat生成的），因此我們必須手動糾正，將Cat.prototype對象的constructor值改爲Cat

。這就是第二行的意思。

這是很重要的一點，編程時務必要遵守。下文都遵循這一點，即如果替換了prototype對象，

o.prototype = {};

那麼，下一步必然是爲新的prototype對象加上constructor屬性，並將這個屬性指回原來的構造函數。

o.prototype.constructor = o;

三、 直接繼承（不推薦使用）

第三種方法是對第二種方法的改進。由於Animal對象中，不變的屬性都可以直接寫入Animal.prototype。所以，我們也可以讓Cat()跳過

Animal()，直接繼承Animal.prototype。

現在，我們先將Animal對象改寫：

function Animal(){ }

Animal.prototype.species ="動物";

然後，將Cat的prototype對象，然後指向Animal的prototype對象，這樣就完成了繼承。

Cat.prototype =Animal.prototype;

Cat.prototype.constructor =Cat;

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

與前一種方法相比，這樣做的優點是效率比較高（不用執行和建立Animal的實例了），比較省內存。缺點是 Cat.prototype和

Animal.prototype現在指向了同一個對象，那麼任何對Cat.prototype的修改，都會反映到Animal.prototype。

所以，上面這一段代碼其實是有問題的。請看第二行

Cat.prototype.constructor =Cat;

這一句實際上把Animal.prototype對象的constructor屬性也改掉了！

alert(Animal.prototype.constructor);// Cat

四、 利用空對象作爲中介（空中繼承）

由於"直接繼承prototype"存在上述的缺點，所以就有第四種方法，利用一個空對象作爲中介。

　　var F = function(){};

　　F.prototype = Animal.prototype;

　　Cat.prototype = new F();

　　Cat.prototype.constructor =Cat;

F是空對象，所以幾乎不佔內存。這時，修改Cat的prototype對象，就不會影響到Animal的prototype對象。

　　alert(Animal.prototype.constructor);// Animal

我們將上面的方法，封裝成一個函數，便於使用。

　　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("大毛","黃色");

　　alert(cat1.species); // 動物

這個extend函數，就是YUI庫如何實現繼承的方法。

另外，說明一點，函數體最後一行

　　Child.uber = Parent.prototype;

意思是爲子對象設一個uber屬性，這個屬性直接指向父對象的prototype屬性。（uber是一個德語詞，意思是"向上"、“上一層”。）這等於在

子對象上打開一條通道，可以直接調用父對象的方法。這一行放在這裏，只是爲了實現繼承的完備性，純屬備用性質。

其實，還可以封裝得更好：

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

注意！此類繼承（使用prototype的繼承）不能繼承父類的原有屬性(this.xxx)，只能繼承原型屬性(prototype.xxx)

五、 拷貝繼承

上面是採用prototype對象，實現繼承。我們也可以換一種思路，純粹採用"拷貝"方法實現繼承。簡單說，如果把父對象的所有屬性和方法，

拷貝進子對象，不也能夠實現繼承嗎？這樣我們就有了第五種方法。

首先，還是把Animal的所有不變屬性，都放到它的prototype對象上。

　　function Animal(){}

　　Animal.prototype.species ="動物";

然後，再寫一個函數，實現屬性拷貝的目的。

　　function extend2(Child, Parent){
　　　　var p = Parent.prototype;
　　　　var c = Child.prototype;
　　　　for (var i in p) {
　　　　　　c[i] = p[i];
　　　　　　}
　　　　c.uber = p;
　　}

這個函數的作用，就是將父對象的prototype對象中的屬性，一一拷貝給Child對象的prototype對象。

使用的時候，這樣寫：

　　extend2(Cat, Animal);
　　var cat1 = new Cat("大毛","黃色");
　　alert(cat1.species); // 動物

注意！此類繼承（使用prototype的繼承）不能繼承父類的原有屬性(this.xxx)，只能繼承原型屬性(prototype.xxx)

非構造函數繼承

一、什麼是"非構造函數"的繼承？

比如，現在有一個對象，叫做"中國人"。

　　var Chinese = {

　　　　nation:'中國'

　　};

還有一個對象，叫做"醫生"。

　　var Doctor ={

　　　　career:'醫生'

　　}

請問怎樣才能讓"醫生"去繼承"中國人"，也就是說，我怎樣才能生成一個"中國醫生"的對象？

這裏要注意，這兩個對象都是普通對象，不是構造函數，無法使用構造函數方法實現"繼承"。

二、object()方法繼承

json格式的發明人Douglas Crockford，提出了一個object()函數，可以做到這一點。

　　function object(o) {

　　　　function F() {}

　　　　F.prototype = o;

　　　　return new F();

　　}

這個object()函數，其實只做一件事，就是把子對象的prototype屬性，指向父對象，從而使得子對象與父對象連在一起。

使用的時候，第一步先在父對象的基礎上，生成子對象：

　　var Doctor = object(Chinese);

然後，再加上子對象本身的屬性：

　　Doctor.career = '醫生';

這時，子對象已經繼承了父對象的屬性了。

　　alert(Doctor.nation); //中國

三、淺拷貝

除了使用"prototype鏈"以外，還有另一種思路：把父對象的屬性，全部拷貝給子對象，也能實現繼承。

下面這個函數，就是在做拷貝：

　　function extendCopy(p) {
　　　　var c = {};
　　　　for (var i in p) {
　　　　　　c[i] = p[i];
　　　　}
　　　　c.uber = p;
　　　　return c;
　　}

使用的時候，這樣寫：

　　var Doctor =extendCopy(Chinese);
　　Doctor.career = '醫生';
　　alert(Doctor.nation); // 中國

但是，這樣的拷貝有一個問題。那就是，如果父對象的屬性等於數組或另一個對象，那麼實際上，子對象獲得的只是一個內存地址，而不是

真正拷貝，因此存在父對象被篡改的可能。

請看，現在給Chinese添加一個"出生地"屬性，它的值是一個數組。

　　Chinese.birthPlaces = ['北京','上海','香港'];

通過extendCopy()函數，Doctor繼承了Chinese。

　　var Doctor =extendCopy(Chinese);

然後，我們爲Doctor的"出生地"添加一個城市：

　　Doctor.birthPlaces.push('廈門');

發生了什麼事？Chinese的"出生地"也被改掉了！

　　alert(Doctor.birthPlaces); //北京, 上海, 香港, 廈門
　　alert(Chinese.birthPlaces); //北京, 上海, 香港, 廈門

所以，extendCopy()只是拷貝基本類型的數據，我們把這種拷貝叫做"淺拷貝"。這是早期jQuery實現繼承的方式。

四、深拷貝

所謂"深拷貝"，就是能夠實現真正意義上重點內容的數組和對象的拷貝。它的實現並不難，只要遞歸調用"淺拷貝"就行了。

　　function deepCopy(p, c) {
　　　　var c = c || {};
　　　　for (var i in p) {
　　　　　　if (typeof p[i] === 'object') {
　　　　　　　　c[i] = (p[i].constructor ===Array) ? [] : {};
　　　　　　　　deepCopy(p[i], c[i]);
　　　　　　} else {
　　　　　　　　　c[i] = p[i];
　　　　　　}
　　　　}
　　　　return c;
　　}

使用的時候這樣寫：

　　var Doctor = deepCopy(Chinese);

現在，給父對象加一個屬性，值爲數組。然後，在子對象上修改這個屬性：

　Chinese.birthPlaces = ['北京','上海','香港'];
　Doctor.birthPlaces.push('廈門');

這時，父對象就不會受到影響了。

　　alert(Doctor.birthPljavascriptaces); //北京, 上海, 香港, 廈門
　　alert(Chinese.birthPlaces); //北京, 上海, 香港

目前，jQuery庫使用的就是這種繼承方法。