引言：Java是基于對象的，為什么這么說呢。作為腳本語言，操控DHTML等網頁內部元素不應該太復雜，為了簡化程序設計，Java中創建了document等重要對象，這些對象是Java的固有對象，用起來十分方便。document對象不妨簡單的理解為用戶界面對象，使用Java編程時常常圍繞著它，而不需要煩鎖的定義、創建等過程。所以Java更多考慮對現有對象的控制，而對對象的創建擴展的能力較差。即便如此，Java仍可創建對象，只是沒有C++那么完整。
一、本文名詞解釋：變量、串對象、對象變量（對象）、原型、原型對象、實例、函數對象(構造函數、構造器)。
為了形象的說明問題，引入名詞“構造器”，構造器指函數對象，在JS中構造器也是構造函數。
對象變量常稱為對象。當變量是個對象時，實際上它是一個指針，該指針指向對象的實際內存位置。對象指針可以復制，內存對象不可復制。要實現真正的復制是一件很麻煩的事情，可以想象，一個對象指針指向document時，要想復制它就很困難，因為document內部有眾多元素并且存在循環引用的問題。
JS中字串不是對象，它可復制，但String對象則不同，它是對象。串變量、數值變量等都不是對象，在賦值時是復制，對象的賦值是指針的復制，而不是實際對象的復制，JS里指針的復制可理解為引用。
關于構造器、構造器的原型（類的原型）、實例、引用原型：構造器是一個函數，函數中有個特殊成員，名為prototype，它是原型對象。函數的prototype對象的成員就是類的屬性、方法的定義部分，但portotype的成員不是構造器屬性、方法的定義，實例是用“new 函數名()”等方法創建的某一個實際的對象。創建對象時須由構造器創建，實例繼承類的構造器portotype中的屬性及方法，為了實現繼承，實例以隱藏方式引用原型對象，這樣當調用繼承的屬性、方法時不需要指明prototype，除此以外，構造器還初始化類，可動態創建類的其它屬性及方法。函數的原型對象就好像可供某工程施工者或本工程項目的用戶使用的公用資料、設備的倉庫，構造器就象圖紙、施工方案等。類的實例就像是根據圖紙建起來的房子（工程案例）。一個實例創建后，它就使用了一定的資源，資源的使用量與構造器的設計有關。一個實例的創建依賴構造器，創建后的實例稱之為某某類(某某構造器)的實例。

二、類的原型與類的實例的創建
在C++中，使用class來定義類。例：
//-----------
class A{
public:
int p;
A(){ p=3; }
m(){ p++; }
};
A b; //創建實例b
//-----------
1、在JS中，函數不僅僅是函數，是一個對象實例。例：
//-----------
a(){…}//創建了一個實例a
a.p=3;//為a添加屬性p
c=a;//c變量是對實例a的引用
c();//與a();調用同一函數
//-----------
2、在JS中既用于定義函數又可用于創建類，用于創建類時，它取代class定義類，這時它就充當了類的構造器的作用，類的名稱就是函數名本身。例：
//-----------
a(){//a類的構造器
this.p=3; //創建public屬性
this.m=(x){this.p+=x;} //創建public方法
}
b=new a();//創建a類的實例
b.m(2);//調用方法
alert(b.p); //結果是5
//-----------
b=new a();語句創建a類的實例。用new創建了一個空對象，new后的構造函數a()對其初始化。
上例中this.p=3;是給當前對象動態創建屬性p，p不是a的屬性，卻是b的屬性，a的屬性并不會復制給b。構造函數執行時通過this關鍵字實現對b動態創建屬性p，初值為3，用b.p取得該屬性。
3、this是一個特殊的對象，表示當前函數的父對象。就是說，誰的成員函數被調用，該函數中的this就是誰。這樣，通過this就可將父對象移到函數體內部來使用，生存期限為函數執行結束。JS的全局變量、函數直接隸屬于window。它們的父對象是window。調用一個函數時，不指明父對象，函數中的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()創建了對象，此時該對象是a()的父對象，該對象只有this可引用得到，a()執行后自動將this返回。但試圖調用b.a()是錯誤的，因為構造函數只能執行一次，執行后就不在是b的成員了。
例：
4、用new創建對象的細節：
使用new a()創建實例時，首先創建空對象，并隱藏引用構造器的的原型對象，使得本實例繼承原型對象中的所有成員。我們不能直接訪問這個隱藏引用，對象建后，內部引用也建立，這時如果重建構造器中的原型對象，該構造器中的原型對象引用仍是原來的，關于prototype的問題下文將詳細說明。其次是執行構造函數，對該對象初始化。其三，將新對象返回。

三、如何創建私有屬性呢？
當函數內部的對象被注冊為外部變量時，函數體內的其它變量成為副本保留。注意，父對象或用new創建的對象也會被注冊到函數體內。
//-----------
a(){
var p=3; //創建private屬性，它是函數內部的變量
  cc(){}//創建private方法
this.m=(x){p+=x; return p;} //創建public方法
}
b=new a();//創建實例
alert(b.m(2)); //結果是5
//-----------
上例中p為對象b的私有屬性，對象的私有屬性、方法只能被其成員方法調用。每次用new創建對象時，構造函數內部的變量及函數都會產生副本，供new創建的對象的成員函數使用。如果創建多個對象，就產生多個副本。每個副本當然會占用一定的內存空間，如何減少副本所占的空間呢？有兩種方法可解決，其一是對函數做引用處理，其二使用繼承的辦法。這里先講一下前者，后者涉及繼承問題，比較麻煩，下文再敘。
當把成員函數移到構造函數外，構造函數在創建方法時使用函數作引用即可減少內存占用。
mm(x){ this.p+=x;}
a(){
this.p=3; //創建private屬性
this.m=mm; //創建public方法,由于mm是個函數對象，這個賦值只是個引用。
}
b=new a();//創建實例
b.m(2);
alert(b.p); //結果是5
一般情況下，內存占用了就不會主動釋放。
這種方式建立的成員函數無法訪問private成員。

四、構造函數中能不能有返回值？
在C++中，構造函數是不能有返回值的。而在java中，用new a()已經創建實例，那么返回值又有何用？其實，當返回值為對象時，new創建的實例不被采用，而使用返回的對象。如：你返回document對象、數組對象、String對象(不是串) 、用new創建的對象等。
a(){
var th=new Array();
th.p=3;
return th;
}
b=new a(); //等價于b=a();使用new時多創建了一個繼承a.prototype的空對象。private空間不變。
使用上例原理創建對象有不少好處：創建public屬性、方法是在th中完成的而不是在this中完成的。this用起來雖然方便但容易造成混亂，當程序比較長是，本人不大喜歡this。private屬性、方法的創建則與前面講的一樣。本例中由于a()有返回值，b接收到的是th對象，b就是th對象的引用。與new a()生成的對象無關，a對象中的prototype也不會被繼承的。有意思的是，當a()返回值是對象時，a()的私有空間沒有釋放，它做為b的private空間，因此這里的b=new a();與b=a();是一樣的，都能訪問其私有空間。再推廣，只要函數內的對象被返回到函數體外部或直接賦值（引用）給外部變量，那么該函數每次執行的private空間就不會被釋放，供這個外部對象變量使用，從語句的形式上看，當函數執行時，只要讓外部變量引用內部對象，該函數就已充當構造器的作用了。例：
//------------------
var kk;
a(){
var c=3;
var th=new Array();
th.m=(){alert(c);}
kk=th;
}
a();
kk.m(); //顯示3
//------------------
當調用函數創建實例，與此同時函數內部對象也被其它外部變量引用時，那么該實例與這個外部變量共用同一個私有空間。例：
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實現繼承（靜態創建成員）
//------------------
a(){ a.prototype.p=3; }
b=new a();//創建實例
//------------------
portotype是對象特有的屬性，類的原型放在的prototype中，我們稱prototype為原型對象，實例繼承原型對象中的所有成員，實例能過隱藏引用了構造器中的原型對象實際繼承，也就是說原型對象中所有成員都可以被實例直接使用，上例中b.p值為3（因為實例的原型引用是隱藏的，無須寫出prototype），而b.prototype.p則不存在。
用例子說明：prototype對象與c++中的public有一定的相似之處，在prototype中定義公有屬性、事件或方法。a.prototype.p與a.p不是同一個變量，prototype中的屬性及方法是類的原型，在new創建時，a.prototype.p并沒有復制給b.prototype.p，因為prototype是對象特有的，不是普通new生成的對象固有的，但new創建的對象內部隱藏引用了構造器中的原型對象，這樣新建的對象就可以通過這個內部引用訪問原型對象中的成員。b.p也不是a.prototype.p的副本，JS在讀取屬性時，先在自身對象中找屬性，如果找不到則在它隱藏引用的原型對象中找。因此，當b.p未定義時，b.p就是a.prototype.p的引用而不是副本；當b.p定義后，b.p就不再是a.protype.p的引用。顯然執行b.p=4是創建了b.p，并不會改變原型a.prototype.p的值。因此，原型中方法、屬性具能“透明”特點，由該原型創建的實例都可“透明”的讀取或調用當時new中的原型對象的成員而不能直接更改它，除非你引用構造器中的原型來修改。這里強調一點：構造器中有原型對象的引用，實例中也有原型對象的隱藏引用，這兩個引用當然指向同一個原型對象，如果你在創建實例后修改了構造器中的原型對象引用，那么實例中的引用的原型對象與構造器中引用的原型對象將不是同一對象。prototype的這些的特性與繼承沒有太大的區別。
構造器中的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()也是構造函數，所以在每次用new創建時實例時都會被執行一次，在執行過程中又創建函數對象 (){ a.prototype.p=4;}，并賦值給m，雖然m只是引用該函數對象，但是這個函數對象是新建的，也就是說每執行一次a()就為m方法創建了一個新的函數對象，這樣是比較耗資源的。如果把m方法的函數對象放在a()之外，m對它做引用就可節省內存。例：
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;}//這樣更好
有得也有失：內存節約了，但沒能以內聯方式書寫程序，程序看上去稍微亂了一點。
以下舉個錯誤的例子：
a(){
a.prototype.p=3;
}
a..m=(){a.prototype.p=4;}
b=new a();
b.m();//錯誤的調用
a..m=(){a.prototype.p=4;}語句給函數對象a添加了方法m()，這個方法不會被繼承，僅對象a自身可使用，只有在prototype中的屬性及方法才會被繼承。使用new和關鍵字均創建對象。一個創建函數對象，一個創建實例。

七、創建子類，即通過某基類創建一個新類：
//------------------
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通過內部原型引用，查找a2.prototype中的成員
a2.prototype也是用new得來的對象，當某成員找不到時，也同樣通過a2.prototype內部的原型引用查找a.prototype中的成員。這樣b繼承了a類與a2類所有的成員。如果a、a2中重名成員，則a2優每
構造器的標準引用就應是引用其自身，a2.prototype.constructor=a2;的作用是使構造器引用標準化，因為a2.prototype=new a();造成a2.prototype.constructor引用a。
六、大括號定義對象，數組定義類
略：
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}