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