引言：Java是基于對象的，為什么這么說呢。作為腳本語言，操控DHTML等網(wǎng)頁內(nèi)部元素不應該太復雜，為了簡化程序設計，Java中創(chuàng)建了document等重要對象，這些對象是Java的固有對象，用起來十分方便。document對象不妨簡單的理解為用戶界面對象，使用Java編程時常常圍繞著它，而不需要煩鎖的定義、創(chuàng)建等過程。所以Java更多考慮對現(xiàn)有對象的控制，而對對象的創(chuàng)建擴展的能力較差。即便如此，Java仍可創(chuàng)建對象，只是沒有C++那么完整。
一、本文名詞解釋：變量、串對象、對象變量（對象）、原型、原型對象、實例、函數(shù)對象(構造函數(shù)、構造器)。
為了形象的說明問題，引入名詞“構造器”，構造器指函數(shù)對象，在JS中構造器也是構造函數(shù)。
對象變量常稱為對象。當變量是個對象時，實際上它是一個指針，該指針指向對象的實際內(nèi)存位置。對象指針可以復制，內(nèi)存對象不可復制。要實現(xiàn)真正的復制是一件很麻煩的事情，可以想象，一個對象指針指向document時，要想復制它就很困難，因為document內(nèi)部有眾多元素并且存在循環(huán)引用的問題。
JS中字串不是對象，它可復制，但String對象則不同，它是對象。串變量、數(shù)值變量等都不是對象，在賦值時是復制，對象的賦值是指針的復制，而不是實際對象的復制，JS里指針的復制可理解為引用。
關于構造器、構造器的原型（類的原型）、實例、引用原型：構造器是一個函數(shù)，函數(shù)中有個特殊成員，名為prototype，它是原型對象。函數(shù)的prototype對象的成員就是類的屬性、方法的定義部分，但portotype的成員不是構造器屬性、方法的定義，實例是用“new 函數(shù)名()”等方法創(chuàng)建的某一個實際的對象。創(chuàng)建對象時須由構造器創(chuàng)建，實例繼承類的構造器portotype中的屬性及方法，為了實現(xiàn)繼承，實例以隱藏方式引用原型對象，這樣當調(diào)用繼承的屬性、方法時不需要指明prototype，除此以外，構造器還初始化類，可動態(tài)創(chuàng)建類的其它屬性及方法。函數(shù)的原型對象就好像可供某工程施工者或本工程項目的用戶使用的公用資料、設備的倉庫，構造器就象圖紙、施工方案等。類的實例就像是根據(jù)圖紙建起來的房子（工程案例）。一個實例創(chuàng)建后，它就使用了一定的資源，資源的使用量與構造器的設計有關。一個實例的創(chuàng)建依賴構造器，創(chuàng)建后的實例稱之為某某類(某某構造器)的實例。
二、類的原型與類的實例的創(chuàng)建
在C++中，使用class來定義類。例：
//-----------
class A{
public:
int p;
A(){ p=3; }
m(){ p++; }
};
A b; //創(chuàng)建實例b
//-----------
1、在JS中，函數(shù)不僅僅是函數(shù)，是一個對象實例。例：
//-----------
a(){…}//創(chuàng)建了一個實例a
a.p=3;//為a添加屬性p
c=a;//c變量是對實例a的引用
c();//與a();調(diào)用同一函數(shù)
//-----------
2、在JS中既用于定義函數(shù)又可用于創(chuàng)建類，用于創(chuàng)建類時，它取代class定義類，這時它就充當了類的構造器的作用，類的名稱就是函數(shù)名本身。例：
//-----------
a(){//a類的構造器
this.p=3; //創(chuàng)建public屬性
this.m=(x){this.p+=x;} //創(chuàng)建public方法
}
b=new a();//創(chuàng)建a類的實例
b.m(2);//調(diào)用方法
alert(b.p); //結果是5
//-----------
b=new a();語句創(chuàng)建a類的實例。用new創(chuàng)建了一個空對象，new后的構造函數(shù)a()對其初始化。
上例中this.p=3;是給當前對象動態(tài)創(chuàng)建屬性p，p不是a的屬性，卻是b的屬性，a的屬性并不會復制給b。構造函數(shù)執(zhí)行時通過this關鍵字實現(xiàn)對b動態(tài)創(chuàng)建屬性p，初值為3，用b.p取得該屬性。
3、this是一個特殊的對象，表示當前函數(shù)的父對象。就是說，誰的成員函數(shù)被調(diào)用，該函數(shù)中的this就是誰。這樣，通過this就可將父對象移到函數(shù)體內(nèi)部來使用，生存期限為函數(shù)執(zhí)行結束。JS的全局變量、函數(shù)直接隸屬于window。它們的父對象是window。調(diào)用一個函數(shù)時，不指明父對象，函數(shù)中的this指window。例：
//-----------
var t=3;
alert(this.t);//顯示3
alert(t);//顯示3
//-----------
//-----------
a(){ this.p=3; }
a();//或a(); a()中的this指window，結果是undefined
b=new Array();
b.c=a;
b.c(); //a中的this指b，結果是3
//-----------
//-----------
a(){ alert(this.b);}
c=new Array("cc");
c.b=3;
c.m=(){ a(); }
c.m(); //顯示undefined，程序中a();語句沒用指明父對象，所以a()中的this指當前腳本的祖宗對象window。
//-----------
一個比較特殊的情況：new a()創(chuàng)建了對象，此時該對象是a()的父對象，該對象只有this可引用得到，a()執(zhí)行后自動將this返回。但試圖調(diào)用b.a()是錯誤的，因為構造函數(shù)只能執(zhí)行一次，執(zhí)行后就不在是b的成員了。
例：
4、用new創(chuàng)建對象的細節(jié)：
使用new a()創(chuàng)建實例時，首先創(chuàng)建空對象，并隱藏引用構造器的的原型對象，使得本實例繼承原型對象中的所有成員。我們不能直接訪問這個隱藏引用，對象建后，內(nèi)部引用也建立，這時如果重建構造器中的原型對象，該構造器中的原型對象引用仍是原來的，關于prototype的問題下文將詳細說明。其次是執(zhí)行構造函數(shù)，對該對象初始化。其三，將新對象返回。
三、如何創(chuàng)建私有屬性呢？
當函數(shù)內(nèi)部的對象被注冊為外部變量時，函數(shù)體內(nèi)的其它變量成為副本保留。注意，父對象或用new創(chuàng)建的對象也會被注冊到函數(shù)體內(nèi)。
//-----------
a(){
var p=3; //創(chuàng)建private屬性，它是函數(shù)內(nèi)部的變量
cc(){}//創(chuàng)建private方法
this.m=(x){p+=x; return p;} //創(chuàng)建public方法
}
b=new a();//創(chuàng)建實例
alert(b.m(2)); //結果是5
//-----------
上例中p為對象b的私有屬性，對象的私有屬性、方法只能被其成員方法調(diào)用。每次用new創(chuàng)建對象時，構造函數(shù)內(nèi)部的變量及函數(shù)都會產(chǎn)生副本，供new創(chuàng)建的對象的成員函數(shù)使用。如果創(chuàng)建多個對象，就產(chǎn)生多個副本。每個副本當然會占用一定的內(nèi)存空間，如何減少副本所占的空間呢？有兩種方法可解決，其一是對函數(shù)做引用處理，其二使用繼承的辦法。這里先講一下前者，后者涉及繼承問題，比較麻煩，下文再敘。
當把成員函數(shù)移到構造函數(shù)外，構造函數(shù)在創(chuàng)建方法時使用函數(shù)作引用即可減少內(nèi)存占用。
mm(x){ this.p+=x;}
a(){
this.p=3; //創(chuàng)建private屬性
this.m=mm; //創(chuàng)建public方法,由于mm是個函數(shù)對象，這個賦值只是個引用。
}
b=new a();//創(chuàng)建實例
b.m(2);
alert(b.p); //結果是5
一般情況下，內(nèi)存占用了就不會主動釋放。
這種方式建立的成員函數(shù)無法訪問private成員。
四、構造函數(shù)中能不能有返回值？
在C++中，構造函數(shù)是不能有返回值的。而在java中，用new a()已經(jīng)創(chuàng)建實例，那么返回值又有何用？其實，當返回值為對象時，new創(chuàng)建的實例不被采用，而使用返回的對象。如：你返回document對象、數(shù)組對象、String對象(不是串) 、用new創(chuàng)建的對象等。
a(){
var th=new Array();
th.p=3;
return th;
}
b=new a(); //等價于b=a();使用new時多創(chuàng)建了一個繼承a.prototype的空對象。private空間不變。
使用上例原理創(chuàng)建對象有不少好處：創(chuàng)建public屬性、方法是在th中完成的而不是在this中完成的。this用起來雖然方便但容易造成混亂，當程序比較長是，本人不大喜歡this。private屬性、方法的創(chuàng)建則與前面講的一樣。本例中由于a()有返回值，b接收到的是th對象，b就是th對象的引用。與new a()生成的對象無關，a對象中的prototype也不會被繼承的。有意思的是，當a()返回值是對象時，a()的私有空間沒有釋放，它做為b的private空間，因此這里的b=new a();與b=a();是一樣的，都能訪問其私有空間。再推廣，只要函數(shù)內(nèi)的對象被返回到函數(shù)體外部或直接賦值（引用）給外部變量，那么該函數(shù)每次執(zhí)行的private空間就不會被釋放，供這個外部對象變量使用，從語句的形式上看，當函數(shù)執(zhí)行時，只要讓外部變量引用內(nèi)部對象，該函數(shù)就已充當構造器的作用了。例：
//------------------
var kk;
a(){
var c=3;
var th=new Array();
th.m=(){alert(c);}
kk=th;
}
a();
kk.m(); //顯示3
//------------------
當調(diào)用函數(shù)創(chuàng)建實例，與此同時函數(shù)內(nèi)部對象也被其它外部變量引用時，那么該實例與這個外部變量共用同一個私有空間。例：
var kk;
a(){
var c=3;
th=new Array();
kk=th;
th.m=(){c++; return c;}
this.m=(){c++; return c;}
}
b=new a();
alert(b.m()); //顯示4
alert(kk.m()); //顯示5
五、使用prototype實現(xiàn)繼承（靜態(tài)創(chuàng)建成員）
//------------------
a(){ a.prototype.p=3; }
b=new a();//創(chuàng)建實例
//------------------
portotype是對象特有的屬性，類的原型放在的prototype中，我們稱prototype為原型對象，實例繼承原型對象中的所有成員，實例能過隱藏引用了構造器中的原型對象實際繼承，也就是說原型對象中所有成員都可以被實例直接使用，上例中b.p值為3（因為實例的原型引用是隱藏的，無須寫出prototype），而b.prototype.p則不存在。
用例子說明：prototype對象與c++中的public有一定的相似之處，在prototype中定義公有屬性、事件或方法。a.prototype.p與a.p不是同一個變量，prototype中的屬性及方法是類的原型，在new創(chuàng)建時，a.prototype.p并沒有復制給b.prototype.p，因為prototype是對象特有的，不是普通new生成的對象固有的，但new創(chuàng)建的對象內(nèi)部隱藏引用了構造器中的原型對象，這樣新建的對象就可以通過這個內(nèi)部引用訪問原型對象中的成員。b.p也不是a.prototype.p的副本，JS在讀取屬性時，先在自身對象中找屬性，如果找不到則在它隱藏引用的原型對象中找。因此，當b.p未定義時，b.p就是a.prototype.p的引用而不是副本；當b.p定義后，b.p就不再是a.protype.p的引用。顯然執(zhí)行b.p=4是創(chuàng)建了b.p，并不會改變原型a.prototype.p的值。因此，原型中方法、屬性具能“透明”特點，由該原型創(chuàng)建的實例都可“透明”的讀取或調(diào)用當時new中的原型對象的成員而不能直接更改它，除非你引用構造器中的原型來修改。這里強調(diào)一點：構造器中有原型對象的引用，實例中也有原型對象的隱藏引用，這兩個引用當然指向同一個原型對象，如果你在創(chuàng)建實例后修改了構造器中的原型對象引用，那么實例中的引用的原型對象與構造器中引用的原型對象將不是同一對象。prototype的這些的特性與繼承沒有太大的區(qū)別。
構造器中的portotype里有constructor成員，它引用構造器本身。
實例有個constructor屬性，它也是繼承來的，它是對構造器的引用。例：
a(){
this.p=3;
}
a.p=4;
kk=new a();
alert(kk.constructor.p); //結果是4
六、提高prototype應用的效率
a(){
a.prototype.p=3;
a.prototype.m=(){ a.prototype.p=4;}
}
本例中定義了方法m()。由于a()也是構造函數(shù)，所以在每次用new創(chuàng)建時實例時都會被執(zhí)行一次，在執(zhí)行過程中又創(chuàng)建函數(shù)對象 (){ a.prototype.p=4;}，并賦值給m，雖然m只是引用該函數(shù)對象，但是這個函數(shù)對象是新建的，也就是說每執(zhí)行一次a()就為m方法創(chuàng)建了一個新的函數(shù)對象，這樣是比較耗資源的。如果把m方法的函數(shù)對象放在a()之外，m對它做引用就可節(jié)省內(nèi)存。例：
abc(){ a.prototype.p=4;}
a(){
a.prototype.p=3;
a.prototype.m=abc;
}
或：
a(){
a.prototype.p=3;
}
a.prototype.m=(){a.prototype.p=4;}//這樣更好
有得也有失：內(nèi)存節(jié)約了，但沒能以內(nèi)聯(lián)方式書寫程序，程序看上去稍微亂了一點。
以下舉個錯誤的例子：
a(){
a.prototype.p=3;
}
a..m=(){a.prototype.p=4;}
b=new a();
b.m();//錯誤的調(diào)用
a..m=(){a.prototype.p=4;}語句給函數(shù)對象a添加了方法m()，這個方法不會被繼承，僅對象a自身可使用，只有在prototype中的屬性及方法才會被繼承。使用new和關鍵字均創(chuàng)建對象。一個創(chuàng)建函數(shù)對象，一個創(chuàng)建實例。
七、創(chuàng)建子類，即通過某基類創(chuàng)建一個新類：
//------------------
a(){ this.p2=2; }
a.prototype.p=1;
a2(){ this.p3=3;}
a2.prototype=new a(); //a2的原型對象由a生成，當然constructor也被繼承
a2.prototype.constructor=a2;//修改constructor，讓它指向自身才時正確的
a2.prototype.p4=4;
b=new a2();
//------------------
a2.prototype含有a的所有屬性
b通過內(nèi)部原型引用，查找a2.prototype中的成員
a2.prototype也是用new得來的對象，當某成員找不到時，也同樣通過a2.prototype內(nèi)部的原型引用查找a.prototype中的成員。這樣b繼承了a類與a2類所有的成員。如果a、a2中重名成員，則a2優(yōu)每
構造器的標準引用就應是引用其自身，a2.prototype.constructor=a2;的作用是使構造器引用標準化，因為a2.prototype=new a();造成a2.prototype.constructor引用a。
六、大括號定義對象，數(shù)組定義類
略：
var _object_types = {
'' : ,
'boolean' : Boolean, 'regexp' : RegExp,// 'math' : Math,// 'debug' : Debug,// 'image' : Image;// 'undef' : undefined,// 'dom' : undefined,// 'activex' : undefined,
'vbarray' : VBArray, 'array' : Array, 'string' : String, 'date' : Date, 'error' : Error, 'enumerator': Enumerator,
'number' : Number, 'object' : Object}
滬公網(wǎng)安備31010802001143號
