一，概述
在Java語言中，我們可以定義自己的類，並根據這些類創建對象來使用，在Javascript中，我們也可以定義自己的類，例如定義User類、Hashtable類等等。
目前在Javascript中，已經存在一些標準的類，例如Date、Array、RegExp、String、Math、Number等等，這爲我們編程提供了許多方便。但對於複雜的客戶端程序而言，這些還遠遠不夠。
與Java不同，Java2提供給我們的標準類很多，基本上滿足了我們的編程需求，但是Javascript提供的標準類很少，許多編程需求需要我們自己去實現，例如Javascript沒有哈西表Hashtable，這樣的話在處理鍵值方面就很不方便。
因此，我個人認爲一個完整的Javascript對象視圖應該如下：
二，基本概念
1，自定義對象。
根據JS的對象擴展機制，用戶可以自定義JS對象，這與Java語言有類似的地方。
與自定義對象相對應的是JS標準對象，例如Date、Array、Math等等。
2，原型（prototype）
在JS中，這是一種創建對象屬性和方法的方式，通過prototype可以爲對象添加新的屬性和方法。
通過prototype我們可以爲JS標準對象添加新的屬性和方法，例如對於String對象，我們可以爲其添加一個新的方法trim（）。
與嚴格的編程語言（例如Java）不同，我們可以在運行期間爲JS對象動態添加新的屬性。
三，語法規則
1，對象創建方式
1）對象初始化器方式
格式：objectName = {property1:value1, property2:value2,..., propertyN:valueN}
property是對象的屬性
value則是對象的值，值可以是字符串、數字或對象三者之一
例如： var user={name:“user1”,age:18}；
var user={name:“user1”,job:{salary:3000,title:programmer}
以這種方式也可以初始化對象的方法，例如：
var user={name:“user1”,age:18,getName:function(){
return this.name;
}
}
後面將以構造函數方式爲重點進行講解，包括屬性和方法的定義等等，也針對構造函數的方式進行講解。
2）構造函數方式
編寫一個構造函數，並通過new方式來創建對象，構造函數本可以帶有構造參數
例如：
function User(name,age){
this.name=name;
this.age=age;
this.canFly=false;
}
var use=new User();
2，定義對象屬性
1）JS中可以爲對象定義三種類型的屬性：私有屬性、實例屬性和類屬性，與Java類似，私有屬性只能在對象內部使用，實例屬性必須通過對象的實例進行引用，而類屬性可以直接通過類名進行引用。
2）私有屬性定義
私有屬性只能在構造函數內部定義與使用。
語法格式：var propertyName=value；
例如：
function User(age){
this.age=age;
var isChild=age<12;
this.isLittleChild=isChild;
}
var user=new User(15);
alert(user.isLittleChild);//正確的方式
alert(user.isChild);//報錯：對象不支持此屬性或方法
3）實例屬性定義，也存在兩種方式：
prototype方式，語法格式：functionName.prototype.propertyName=value
this方式，語法格式：this.propertyName=value，注意後面例子中this使用的位置
上面中value可以是字符創、數字和對象。
例如：
function User(){ }
User.prototype.name=“user1”;
User.prototype.age=18;
var user=new User();
alert(user.age);
-----------------------------------------
function User(name,age,job){
this.name=“user1”;
this.age=18;
this.job=job;
}
alert(user.age);
3）類屬性定義
語法格式：functionName.propertyName=value
例如：
function User(){ }
User.MAX_AGE=200;
User.MIN_AGE=0;
alert(User.MAX_AGE);
參考JS標準對象的類屬性：
Number.MAX_VALUE //最大數值 Math.PI //圓周率
4）對於屬性的定義，除了上面較爲正規的方式外，還有一種非常特別的定義方式，語法格式： obj[index]=value
例子：
function User(name){
this.name=name;
this.age=18;
this[1]=“ok”;
this[200]=“year”;
}
var user=new User(“user1”);
alert(user[1]);
在上面例子中，要注意：不同通過this[1]來獲取age屬性，也不能通過this[0]來獲取name屬性，即通過index方式定義的必須使用index方式來引用，而沒有通過index方式定義的，必須以正常方式引用
3，定義對象方法
1）JS中可以爲對象定義三種類型的方法：私有方法、實例方法和類方法，與Java類似：
私有方法只能在對象內部使用
實例方法必須在對象實例化後才能使用
類方法可以直接通過類名去使用
注意：方法的定義不能通過前面所說的index方式進行。
2）定義私有方法
私有方法必須在構造函數體內定義，而且只能在構造函數體內使用。
語法格式：function methodName(arg1,…,argN){ }
例如：
function User(name){
this.name=name;
function getNameLength(nameStr){
return nameStr.length;
}
this.nameLength=getNameLength(this.name);
}
3）定義實例方法，目前也可以使用兩種方式：
prototype方式，在構造函數外使用，語法格式：
functionName.prototype.methodName=method;
或者
functionName.prototype.methodName=function(arg1,…,argN){};
this方式，在構造函數內部使用，語法格式：
this.methodName=method;
或者
this.methodName=function(arg1,…,argN){};
上面的語法描述中，method是外部已經存在的一個方法，methodName要定義的對象的方法，意思就是將外部的一個方法直接賦給對象的某個方法。
以function(arg1,…,argN){}的方式定義對象方法是開發人員應該掌握的。
定義實例方法的一些例子：例子1
function User(name){
this.name=name;
this.getName=getUserName;
this.setName=setUserName;
}
function getUserName(){
return this.name;
}
Function setUserName(name){
this.name=name;
}
定義實例方法的一些例子：例子2
function User(name){
this.name=name;
this.getName=function(){
return this.name;
};
this.setName=function(newName){
this.name=newName;
};
}
定義實例方法的一些例子：例子3
function User(name){
this.name=name;
}
User.prototype.getName=getUserName;
User.prototype.setName=setUserName();
function getUserName(){
return this.name;
}
Function setUserName(name){
this.name=name;
}
定義實例方法的一些例子：例子4
function User(name){
this.name=name;
}
User.prototype.getName=function(){
return this.name;
};
User.prototype.setName=function(newName){
this.name=newName;
};
4）定義類方法
類方法需要在構造函數外面定義，可以直接通過構造函數名對其進行引用。
語法格式：
functionName.methodName=method;
或者
functionName.methodName=function(arg1,…,argN){};
例子：
function User(name){
this.name=name;
}
User.getMaxAge=getUserMaxAge;
function getUserMaxAge(){
return 200;
}
或者
User.getMaxAge=function(){return 200;};
alert(User.getMaxAge());
4，屬性與方法的引用
1）從可見性上說：
私有屬性與方法，只能在對象內部引用。
實例屬性與方法，可以在任何地方使用，但必須通過對象來引用。
類屬性與方法，可以在任何地方使用，但不能通過對象的實例來引用（這與Java不同，在Java中靜態成員可以通過實例來訪問）。
2）從對象層次上說：
與Java bean的引用類似，可以進行深層次的引用。
幾種方式：
簡單屬性：obj.propertyName
對象屬性：obj.innerObj.propertyName
索引屬性：obj.propertyName[index]
對於更深層次的引用與上面類似。
3）從定義方式上說：
通過index方式定義的屬性，必須通過index方式才能引用。
通過非index方式定義的屬性，必須通過正常的方式才能引用。
另外注意：對象的方法不能通過index方式來定義。
5，屬性與方法的動態增加和刪除
1）對於已經實例化的對象，我們可以動態增加和刪除它的屬性與方法，語法如下（假定對象實例爲obj）：
動態增加對象屬性
obj.newPropertyName=value;
動態增加對象方法
obj.newMethodName=method或者=function(arg1,…,argN){}
動態刪除對象屬性
delete obj.propertyName
動態刪除對象方法
delete obj.methodName
2）例子：
function User(name){
this.name=name;
this.age=18;
}
var user=new User(“user1”);
user.sister=“susan”;
alert(user.sister);//運行通過
delete user.sister;
alert(user.sister);//報錯：對象不支持該屬性
user.getMotherName=function(){return “mary”;}
alert(user.getMotherName());//運行通過
delete user.getMotherName;
alert(user.getMotherName());//報錯：對象不支持該方法
定義類或對象
雖然ECMAScript越來越正規化了，但創建對象的方法卻被置之不理。在高級的編程語言（如C#）中，創建對象的方法被明確的定義了。所以不會有太大的分歧。但在腳本語言中創建對象的方法就是多種多樣了。
4.1 工廠方式
由於對象的屬性可在對象創建後動態定義，所以許多開發者都在初次引入JavaScript時編寫類似下面的代碼：Var oCar=new Object();
oCar.color="red";
oCar.doors=4;
oCar.mpg=23;
oCar.showColor=function(){alert(this.color);};
在這段代碼中，創建對象car。然後給它設置幾個屬性：它的顏色是紅色，有四個門，每加侖油23英里。最後一個屬性是指向函數的指針，意味着該屬性其實是個方法。執行這段代碼後，就可以使用對象car了。可是要創建多個car實例就麻煩了。
要解決此問題，開發者可以創建並返回特定類型的對象的工廠函數。例如，函數CreateCar（）可用於封裝前面列出的創建car對象的操作：Function createCar()
{
Var oTempCar=new Object();
oTempCar.color="red";
oTempCar.doors=4;
oTempCar.mpg=23;
oTempCar.showColor=function(){alert(this.color)};
return oTempCar;
}
Var oCar1=createCar();
Var oCar2=createCar();
這裏，前面的所有代碼都包含在createCar()函數中，此外還有一行額外的代碼，返回Car對象作爲函數值。調用此函數時，將創建新對象，並賦予它所有必要的屬性，複製出一個前面說明的car對象。使用該方法，可以容易地創建car對象的兩個版本，他們的屬性完全一樣。當然，還可以修改creatCar（）函數，給它傳遞各個屬性的默認值，而不是賦予屬性默認值：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",2,26);
oCar1.showColor(); // 輸出"red"
oCar2.showColor(); // 輸出"blue"
給createCar（）函數加上參數，即可爲要創建的car對象的color、doors和mpg屬性賦值。使這兩個對象具有相同的屬性，卻有不同的屬性值。但這裏有個問題：每次調用函數createCar（），都要創建新函數showColor()，意味着每個對象都有自己的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",4,23);
Var oCar2=new Car("blue",2,26);
oCar1.showColor(); // 輸出"red"
oCar2.showColor(); // 輸出"blue"
這個方法和上一個方法有個一樣的缺陷：重複的創建了showColor()函數。爲了解決這個缺陷我們可以用下面的方法。
4.2 原型方式
該方法利用了對象的Prototype屬性。用空構造函數來設置類名，然後所有的屬性和方法都被直接賦予prototype屬性：Function Car()
{}
Car.prototype.color="red";
Car.prototype.doors=4;
Car.prototype.mpg=23;
Car.prototype.showColor=function(){alert(this.color)};
Var oCar1=new Car();
Var oCar2=new Car();
使用這個方法可以解決重複創建showColor（）函數，但又會有新的問題，考慮下面的例子：Function Car()
{}
Car.prototype.color="red";
Car.prototype.doors=4;
Car.prototype.mpg=23;
Car.prototype.drivers=new Array("Mike","Sue");
Car.prototype.showColor=function(){alert(this.color)};
Var oCar1=new Car();
Var oCar2=new Car();
oCar1.drivers.push("Matt");
alert(oCar1.drivers); // 輸出"Mike,Sue,Matt"
alert(oCar2.drivers); // 輸出"Mike,Sue,Matt"
這裏，屬性drivers是指向Array對象的指針。改變指針指向的內容，所有的實例都會改變。看來這種方法也不可取
4.3 混合方式
這種方式就是用構造函數定義對象的所有非函數屬性，用原型方式定義對象的函數屬性（方法）。結果所有的函數只創建一次，而每個對象都具有自己的對象屬性實例。Function Car(sColor,iDoors,iMpg)
{
this.color= sColor;
this.doors= iDoors;
this.mpg= iMpg;
Car.drivers=new Array("Mike","Sue");
}
Car.prototype.showColor=function(){alert(this.color)};
Var oCar1=new Car("red",4,23);
Var oCar2=new Car("blue",3,25);
oCar1.drivers.push("Matt");
alert(oCar1.drivers); // 輸出"Mike,Sue,Matt"
alert(oCar2.drivers); // 輸出"Mike,Sue"
這種方式是ECMAScript主要採用的方式，它具有其他方式的特性，卻沒有它們的缺陷。在實際編程中應用的也是最多了