面向對象
一種面向對象語言需要向開發者提供四種基本能力：
- 封裝 - 把相關的信息（無論數據或方法）存儲在對象中的能力
- 聚集 - 把一個對象存儲在另一個對象內的能力
- 繼承 - 由另一個類（或多個類）得來類的屬性和方法的能力
- 多態 - 編寫能以多種方法運行的函數或方法的能力
ECMAScript 支持這些要求，因此可被是看做面向對象的。
<br />
對象應用
聲明和實例化
對象的創建方式是用關鍵字 new 后面跟上實例化的類的名字：
var oObject = new Object();
var oStringObject = new String();
<br />
對象引用
在前面的章節中，我們介紹了引用類型的概念。在ECMAScript中，不能訪問對象的物理表示，只能訪問對象的引用。每次創建對象，存儲在變量中的都是該對象的引用，而不是對象本身。
<br />
對象廢除
ECMAScript 擁有無用存儲單元收集程序（garbage collection routine），意味著不必專門銷毀對象來釋放內存。當再沒有對對象的引用時，稱該對象被廢除（dereference）了。
。每當函數執行完它的代碼，無用存儲單元收集程序都會運行，釋放所有的局部變量，還有在一些其他不可預知的情況下，無用存儲單元收集程序也會運行。
把對象的所有引用都設置為 null，可以強制性地廢除對象。例如：
var oObject = new Object;
// do something with the object here
oObject = null;
每用完一個對象后，就將其廢除，來釋放內存，這是個好習慣。
注意：廢除對象的所有引用時要當心。如果一個對象有兩個或更多引用，則要正確廢除該對象，必須將其所有引用都設置為 null。
<br />
早綁定和晚綁定
所謂綁定（binding），即把對象的接口與對象實例結合在一起的方法。
早綁定（early binding）是指在實例化對象之前定義它的屬性和方法，ECMAScript 不是強類型語言，所以不支持早綁定。
晚綁定（late binding）指的是編譯器或解釋程序在運行前，不知道對象的類型。使用晚綁定，無需檢查對象的類型，只需檢查對象是否支持屬性和方法即可。ECMAScript 中的所有變量都采用晚綁定方法。這樣就允許執行大量的對象操作，而無任何懲罰。
<br />
對象類型
一般來說，可以創建并使用的對象有三種：本地對象、內置對象和宿主對象。
本地對象(Boolean, Number, String...)
ECMA-262 把本地對象（native object）定義為“獨立于宿主環境的 ECMAScript 實現提供的對象”。簡單來說，本地對象就是 ECMA-262 定義的類（引用類型）。它們包括：
- Object
- Function
- Array
- String
- Boolean
- Number
- Date
- RegExp
- Error
- EvalError
- RangeError
- ReferenceError
- SyntaxError
- TypeError
- URIError
<br />
內置對象(Global & Math)
ECMA-262把內置對象（built-in object）定義為“由ECMAScript實現提供的、獨立于宿主環境的所有對象，在ECMAScript程序開始執行時出現”。這意味著開發者不必明確實例化內置對象，它已被實例化了。ECMA-262 只定義了兩個內置對象，即 Global 和 Math （它們也是本地對象，根據定義，每個內置對象都是本地對象）。
<br />
宿主對象(BOM & DOM)
所有非本地對象都是宿主對象（host object），即由 ECMAScript 實現的宿主環境提供的對象。
所有 BOM 和 DOM 對象都是宿主對象。
<br />
對象作用域
公用、私有和受保護作用域
在傳統的面向對象程序設計中，包含公有、私有、保護作用域。
ECMAScript 只有公用作用域，ECMAScript 中的所有對象的所有屬性和方法都是公用的。因此，定義自己的類和對象時，必須格外小心。記住，所有屬性和方法默認都是公用的！
由于缺少私有作用域，開發者確定了一個規約，說明哪些屬性和方法應該被看做私有的。這種規約規定在屬性前后加下劃線：
obj._color_ = "blue";
注意，下劃線并不改變屬性是公用屬性的事實，它只是告訴其他開發者，應該把該屬性看作私有的。
<br />
靜態作用域
靜態作用域定義的屬性和方法任何時候都能從同一位置訪問。在 Java 中，類可具有屬性和方法，無需實例化該類的對象，即可訪問這些屬性和方法，例如 java.net.URLEncoder 類，它的函數 encode() 就是靜態方法。
ECMAScript 沒有靜態作用域
嚴格來說，ECMAScript 并沒有靜態作用域。不過，它可以給構造函數提供屬性和方法。還記得嗎，構造函數只是函數。函數是對象，對象可以有屬性和方法。例如：
function sayHello()
{
alert("hello");
}
sayHello.alternate = function() // 為函數添加方法
{
alert("hi");
}
sayHello(); // 輸出 "hello"，可理解為構造函數的調用
sayHello.alternate(); // 輸出 "hi"，類靜態方法式的調用
即使如此，alternate() 也是 sayHello() 公用作用域中的方法，而不是靜態方法。
<br />
關鍵字this
它用在對象的方法中。關鍵字 this 總是指向調用該方法的對象，例如：
function showColor() {
alert(this.color);
};
var oCar1 = new Object;
oCar1.color = "red";
oCar1.showColor = showColor;
var oCar2 = new Object;
oCar2.color = "blue";
oCar2.showColor = showColor;
oCar1.showColor(); // 輸出 "red"
oCar2.showColor(); // 輸出 "blue"
注意，引用對象的屬性時，必須使用 this 關鍵字。例如，如果采用下面的代碼，showColor() 方法不能運行：
function showColor() {
alert(color);
};
如果不用對象或 this 關鍵字引用變量，ECMAScript 就會把它看作局部變量或全局變量。然后該函數將查找名為 color 的局部或全局變量，但是不會找到。結果如何呢？該函數將在警告中顯示 "null"。
<br >
定義類和對象
原始的方式
var oCar = new Object;
oCar.color = "blue";
oCar.doors = 4;
oCar.mpg = 25;
oCar.showColor = function() {
alert(this.color);
};
<br />
工廠方式
function createCar(sColor,iDoors,iMpg) {
var oTempCar = new Object;
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = function() { // 函數對象每次都會重新創建
alert(this.color);
};
return oTempCar;
}
var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);
oCar1.showColor(); //輸出 "red"
oCar2.showColor(); //輸出 "blue"
前面的例子中，每次調用函數 createCar()，都要創建新函數 showColor()，意味著每個對象都有自己的 showColor() 版本。而事實上，每個對象都共享同一個函數。
所以改進的版本如下：
function showColor() {
alert(this.color);
}
function createCar(sColor,iDoors,iMpg) {
var oTempCar = new Object;
oTempCar.color = sColor;
oTempCar.doors = iDoors;
oTempCar.mpg = iMpg;
oTempCar.showColor = showColor; // 共享函數對象
return oTempCar;
}
var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);
oCar1.showColor(); //輸出 "red"
oCar2.showColor(); //輸出 "blue"
在createCar()內部，賦予對象一個指向已經存在的showColor()函數的指針。從功能上講，這樣解決了重復創建函數對象的問題；但是從語義上講，該函數不太像是對象的方法。
<br />
構造函數方式
創建構造函數就像創建工廠函數一樣容易。第一步選擇類名，即構造函數的名字。根據慣例，這個名字的首字母大寫，以使它與首字母通常是小寫的變量名分開。除了這點不同，構造函數看起來很像工廠函數。請考慮下面的例子：
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.showColor = function() { // 每次都會創建函數對象
alert(this.color);
};
}
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);
下面為您解釋上面的代碼與工廠方式的差別。首先在構造函數內沒有創建對象，而是使用 this 關鍵字。使用 new 運算符構造函數時，在執行第一行代碼前先創建一個對象，只有用 this 才能訪問該對象。然后可以直接賦予 this 屬性，默認情況下是構造函數的返回值（不必明確使用 return 運算符）。
就像工廠函數，構造函數會重復生成函數，為每個對象都創建獨立的函數版本。不過，與工廠函數相似，也可以用外部函數重寫構造函數，同樣地，這么做語義上無任何意義。這正是下面要講的原型方式的優勢所在。
<br />
原型方式(prototype)
該方式利用了對象的 prototype 屬性，可以把它看成創建新對象所依賴的原型。
這里，首先用空構造函數來設置類名。然后所有的屬性和方法都被直接賦予 prototype 屬性。我們重寫了前面的例子，代碼如下：
function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.showColor = function() {
alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();
調用 new Car() 時，原型的所有屬性都被立即賦予要創建的對象，意味著所有 Car 實例存放的都是指向 showColor() 函數的指針。從語義上講，所有屬性看起來都屬于一個對象，因此解決了前面兩種方式存在的問題。
原型方式看起來是個不錯的解決方案。遺憾的是，它并不盡如人意。
首先，這個構造函數沒有參數。
真正的問題出現在屬性指向的是對象，而不是函數時。函數共享不會造成問題，但對象共享卻會造成問題。請思考下面的例子：
function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function() {
alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.drivers.push("Bill");
alert(oCar1.drivers); //輸出 "Mike,John,Bill"
alert(oCar2.drivers); //輸出 "Mike,John,Bill"
<br />
混合的構造函數/原型方式
由于創建對象時有這么多問題，你一定會想，是否有種合理的創建對象的方法呢？
答案是有，需要聯合使用構造函數和原型方式。
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike","John"); // 避免對象共享
}
Car.prototype.showColor = function() { // 使用函數共享
alert(this.color);
};
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);
oCar1.drivers.push("Bill");
alert(oCar1.drivers); // 輸出 "Mike,John,Bill"
alert(oCar2.drivers); // 輸出 "Mike,John"
<br />
動態原型方法(_initialized)
對于習慣使用其他語言的開發者來說，使用混合的構造函數/原型方式感覺不那么和諧。畢竟，定義類時，大多數面向對象語言都對屬性和方法進行了視覺上的封裝。
動態原型方法的基本想法與混合的構造函數/原型方式相同，唯一的區別是賦予函數屬性的位置。下面是用動態原型方法重寫的 Car 類：
function Car(sColor,iDoors,iMpg) {
this.color = sColor;
this.doors = iDoors;
this.mpg = iMpg;
this.drivers = new Array("Mike","John");
if (typeof Car._initialized == "undefined") { // 保證函數屬性只定義一次
Car.prototype.showColor = function() {
alert(this.color);
};
Car._initialized = true; // 定義后，"typeof"運算符返回"boolean"
}
}
直到檢查typeof Car._initialized是否等于"undefined"之前，這個構造函數都未發生變化。這行代碼是動態原型方法中最重要的部分。如果這個值未定義，構造函數將用原型方式繼續定義對象的方法，然后把Car._initialized設置為true。如果這個值定義了（它的值為true時，typeof的值為boolean），那么就不再創建該方法。
<br />
如前所述，目前使用最廣泛的是混合的構造函數/原型方式。此外，動態原始方法也很流行，在功能上與構造函數/原型方式等價。可以采用這兩種方式中的任何一種。
<br />
修改對象
prototype 屬性不僅可以定義構造函數的屬性和方法，還可以為本地對象添加屬性和方法。
創建新方法
通過已有的方法創建新方法
Number.prototype.toHexString = function() {
return this.toString(16);
};
<br />
重命名已有方法
Array.prototype.enqueue = function(vItem) {
this.push(vItem);
};
Array.prototype.dequeue = function() {
return this.shift();
};
<br />
添加與已有方法無關的方法
Array.prototype.indexOf = function (vItem) {
for (var i=0; i<this.length; i++) {
if (vItem == this[i]) {
return i;
}
}
return -1;
}
<br />
為所有本地對象添加新方法
所有本地對象都繼承了 Object 對象，所以對 Object 對象做任何改變，都會反應在所有本地對象上。
Object.prototype.showValue = function () {
alert(this.valueOf());
};
var str = "hello";
var iNum = 25;
str.showValue(); // 輸出 "hello"
iNum.showValue(); // 輸出 "25"
<br />
重定義已有方法
如前面的章節所述，函數名只是指向函數的指針，因此可以輕松地指向其他函數。
Function.prototype.toString = function() {
return "Function code hidden";
}
不過，toString()指向的原始函數怎么了呢？
它將被無用存儲單元回收程序回收，因為它被完全廢棄了。沒有能夠恢復原始函數的方法，所以在覆蓋原始方法前，比較安全的做法是存儲它的指針，以便以后的使用。有時你甚至可能在新方法中調用原始方法：
Function.prototype.originalToString = Function.prototype.toString;
Function.prototype.toString = function() {
if (this.originalToString().length > 100) {
return "Function too long to display.";
} else {
return this.originalToString();
}
};
<br />
極晚綁定(Very Late Binding)
在大多數程序設計語言中，必須在實例化對象之前定義對象的方法。 ECMAScript允許在對象實例化后再定義它的方法。
var o = new Object();
Object.prototype.sayHi = function () {
alert("hi");
};
o.sayHi();
注意：不建議使用極晚綁定方法，因為很難對其跟蹤和記錄。不過，還是應該了解這種可能。
<br />
更多請參考：W3School
