“盡管以C++為基礎，但Java是壹種更純粹的面向對象程序設計語言”。
無論C++還是Java都屬於雜合語言。但在Java中，設計者覺得這種雜合並不象在C++裏那麽重要。雜合語言允許采用多種編程風格；之所以說C++是壹種雜合語言，是因為它支持與C語言的向後兼容能力。由於C++是C的壹個超集，所以包含的許多特性都是後者不具備的，這些特性使C++在某些地方顯得過於復雜。
Java語言首先便假定了我們只希望進行面向對象的程序設計。也就是說，正式用它設計之前，必須先將自己的思想轉入壹個面向對象的世界（除非早已習慣了這個世界的思維方式）。只有做好這個準備工作，與其他OOP語言相比，才能體會到Java的易學易用。在本章，我們將探討Java程序的基本組件，並體會為什麽說Java乃至Java程序內的壹切都是對象。
2.1 用句柄操縱對象
每種編程語言都有自己的數據處理方式。有些時候，程序員必須時刻留意準備處理的是什麽類型。您曾利用壹些特殊語法直接操作過對象，或處理過壹些間接表示的對象嗎（C或C++裏的指針）？
所有這些在Java裏都得到了簡化，任何東西都可看作對象。因此，我們可采用壹種統壹的語法，任何地方均可照搬不誤。但要註意，盡管將壹切都“看作”對象，但操縱的標識符實際是指向壹個對象的“句柄”（Handle）。在其他Java參考書裏，還可看到有的人將其稱作壹個“引用”，甚至壹個“指針”。可將這壹情形想象成用遙控板（句柄）操縱電視機（對象）。只要握住這個遙控板，就相當於掌握了與電視機連接的通道。但壹旦需要“換頻道”或者“關小聲音”，我們實際操縱的是遙控板（句柄），再由遙控板自己操縱電視機（對象）。如果要在房間裏四處走走，並想保持對電視機的控制，那麽手上拿著的是遙控板，而非電視機。
此外，即使沒有電視機，遙控板亦可獨立存在。也就是說，只是由於擁有壹個句柄，並不表示必須有壹個對象同它連接。所以如果想容納壹個詞或句子，可創建壹個String句柄：
String s;
但這裏創建的只是句柄，並不是對象。若此時向s發送壹條消息，就會獲得壹個錯誤（運行期）。這是由於s實際並未與任何東西連接（即“沒有電視機”）。因此，壹種更安全的做法是：創建壹個句柄時，記住無論如何都進行初始化：
String s = "asdf";
然而，這裏采用的是壹種特殊類型：字串可用加引號的文字初始化。通常，必須為對象使用壹種更通用的初始化類型。
2.2 所有對象都必須創建
創建句柄時，我們希望它同壹個新對象連接。通常用new關鍵字達到這壹目的。new的意思是：“把我變成這些對象的壹種新類型”。所以在上面的例子中，可以說：
String s = new String("asdf");
它不僅指出“將我變成壹個新字串”，也通過提供壹個初始字串，指出了“如何生成這個新字串”。
當然，字串（String）並非唯壹的類型。Java配套提供了數量眾多的現成類型。對我們來講，最重要的就是記住能自行創建類型。事實上，這應是Java程序設計的壹項基本操作，是繼續本書後余部分學習的基礎。
2.2.1 保存到什麽地方
程序運行時，我們最好對數據保存到什麽地方做到心中有數。特別要註意的是內存的分配。有六個地方都可以保存數據：
(1) 寄存器。這是最快的保存區域，因為它位於和其他所有保存方式不同的地方：處理器內部。然而，寄存器的數量十分有限，所以寄存器是根據需要由編譯器分配。我們對此沒有直接的控制權，也不可能在自己的程序裏找到寄存器存在的任何蹤跡。
(2) 堆棧。駐留於常規RAM（隨機訪問存儲器）區域，但可通過它的“堆棧指針”獲得處理的直接支持。堆棧指針若向下移，會創建新的內存；若向上移，則會釋放那些內存。這是壹種特別快、特別有效的數據保存方式，僅次於寄存器。創建程序時，Java編譯器必須準確地知道堆棧內保存的所有數據的“長度”以及“存在時間”。這是由於它必須生成相應的代碼，以便向上和向下移動指針。這壹限制無疑影響了程序的靈活性，所以盡管有些Java數據要保存在堆棧裏——特別是對象句柄，但Java對象並不放到其中。
(3) 堆。壹種常規用途的內存池（也在RAM區域），其中保存了Java對象。和堆棧不同，“內存堆”或“堆”（Heap）最吸引人的地方在於編譯器不必知道要從堆裏分配多少存儲空間，也不必知道存儲的數據要在堆裏停留多長的時間。因此，用堆保存數據時會得到更大的靈活性。要求創建壹個對象時，只需用new命令編制相關的代碼即可。執行這些代碼時，會在堆裏自動進行數據的保存。當然，為達到這種靈活性，必然會付出壹定的代價：在堆裏分配存儲空間時會花掉更長的時間！
(4) 靜態存儲。這兒的“靜態”（Static）是指“位於固定位置”（盡管也在RAM裏）。程序運行期間，靜態存儲的數據將隨時等候調用。可用static關鍵字指出壹個對象的特定元素是靜態的。但Java對象本身永遠都不會置入靜態存儲空間。
(5) 常數存儲。常數值通常直接置於程序代碼內部。這樣做是安全的，因為它們永遠都不會改變。有的常數需要嚴格地保護，所以可考慮將它們置入只讀存儲器（ROM）。
(6) 非RAM存儲。若數據完全獨立於壹個程序之外，則程序不運行時仍可存在，並在程序的控制範圍之外。其中兩個最主要的例子便是“流式對象”和“固定對象”。對於流式對象，對象會變成字節流，通常會發給另壹臺機器。而對於固定對象，對象保存在磁盤中。即使程序中止運行，它們仍可保持自己的狀態不變。對於這些類型的數據存儲，壹個特別有用的技巧就是它們能存在於其他媒體中。壹旦需要，甚至能將它們恢復成普通的、基於RAM的對象。Java 1.1提供了對Lightweight persistence的支持。未來的版本甚至可能提供更完整的方案。
2.2.2 特殊情況：主要類型
有壹系列類需特別對待；可將它們想象成“基本”、“主要”或者“主”（Primitive）類型，進行程序設計時要頻繁用到它們。之所以要特別對待，是由於用new創建對象（特別是小的、簡單的變量）並不是非常有效，因為new將對象置於“堆”裏。對於這些類型，Java采納了與C和C++相同的方法。也就是說，不是用new創建變量，而是創建壹個並非句柄的“自動”變量。這個變量容納了具體的值，並置於堆棧中，能夠更高效地存取。
Java決定了每種主要類型的大小。就象在大多數語言裏那樣，這些大小並不隨著機器結構的變化而變化。這種大小的不可更改正是Java程序具有很強移植能力的原因之壹。
主類型
大小
最小值
最大值
封裝器類型
boolean
1-bit
–
–
Boolean
char
16-bit
Unicode 0
Unicode 216- 1
Character
byte
8-bit
-128
+127
Byte[11]
short
16-bit
-215
+215 – 1
Short1
int
32-bit
-231
+231 – 1
Integer
long
64-bit
-263
+263 – 1
Long
float
32-bit
IEEE754
IEEE754
Float
double
64-bit
IEEE754
IEEE754
Double
void
–
–
–
Void1
①：到Java 1.1才有，1.0版沒有。
數值類型全都是有符號（正負號）的，所以不必費勁尋找沒有符號的類型。
主數據類型也擁有自己的“封裝器”（wrapper）類。這意味著假如想讓堆內壹個非主要對象表示那個主類型，就要使用對應的封裝器。例如：
char c = 'x';
Character C = new Character('c');
也可以直接使用：
Character C = new Character('x');
這樣做的原因將在以後的章節裏解釋。
1. 高精度數字
Java 1.1增加了兩個類，用於進行高精度的計算：BigInteger和BigDecimal。盡管它們大致可以劃分為“封裝器”類型，但兩者都沒有對應的“主類型”。
這兩個類都有自己特殊的“方法”，對應於我們針對主類型執行的操作。也就是說，能對int或float做的事情，對BigInteger和BigDecimal壹樣可以做。只是必須使用方法調用，不能使用運算符。此外，由於牽涉更多，所以運算速度會慢壹些。我們犧牲了速度，但換來了精度。
BigInteger支持任意精度的整數。也就是說，我們可精確表示任意大小的整數值，同時在運算過程中不會丟失任何信息。
BigDecimal支持任意精度的定點數字。例如，可用它進行精確的幣值計算。
至於調用這兩個類時可選用的構建器和方法，請自行參考聯機幫助文檔。
2.2.3 Java的數組
幾乎所有程序設計語言都支持數組。在C和C++裏使用數組是非常危險的，因為那些數組只是內存塊。若程序訪問自己內存塊以外的數組，或者在初始化之前使用內存（屬於常規編程錯誤），會產生不可預測的後果（註釋②）。
②：在C++裏，應盡量不要使用數組，換用標準模板庫（Standard TemplateLibrary）裏更安全的容器。
Java的壹項主要設計目標就是安全性。所以在C和C++裏困擾程序員的許多問題都未在Java裏重復。壹個Java可以保證被初始化，而且不可在它的範圍之外訪問。由於系統自動進行範圍檢查，所以必然要付出壹些代價：針對每個數組，以及在運行期間對索引的校驗，都會造成少量的內存開銷。但由此換回的是更高的安全性，以及更高的工作效率。為此付出少許代價是值得的。
創建對象數組時，實際創建的是壹個句柄數組。而且每個句柄都會自動初始化成壹個特殊值，並帶有自己的關鍵字：null（空）。壹旦Java看到null，就知道該句柄並未指向壹個對象。正式使用前，必須為每個句柄都分配壹個對象。若試圖使用依然為null的壹個句柄，就會在運行期報告問題。因此，典型的數組錯誤在Java裏就得到了避免。
也可以創建主類型數組。同樣地，編譯器能夠擔保對它的初始化，因為會將那個數組的內存劃分成零。
數組問題將在以後的章節裏詳細討論。
2.3 絕對不要清除對象
在大多數程序設計語言中，變量的“存在時間”（Lifetime）壹直是程序員需要著重考慮的問題。變量應持續多長的時間？如果想清除它，那麽何時進行？在變量存在時間上糾纏不清會造成大量的程序錯誤。在下面的小節裏，將闡示Java如何幫助我們完成所有清除工作，從而極大了簡化了這個問題。
2.3.1 作用域
大多數程序設計語言都提供了“作用域”（Scope）的概念。對於在作用域裏定義的名字，作用域同時決定了它的“可見性”以及“存在時間”。在C，C++和Java裏，作用域是由花括號的位置決定的。參考下面這個例子：
{
int x = 12;
/* only x available */
{
int q = 96;
/* both x & q available */
}
/* only x available */
/* q “out of scope” */
}
作為在作用域裏定義的壹個變量，它只有在那個作用域結束之前才可使用。
在上面的例子中，縮進排版使Java代碼更易辨讀。由於Java是壹種形式自由的語言，所以額外的空格、制表位以及回車都不會對結果程序造成影響。
註意盡管在C和C++裏是合法的，但在Java裏不能象下面這樣書寫代碼：
{
int x = 12;
{
int x = 96; /* illegal */
}
}
編譯器會認為變量x已被定義。所以C和C++能將壹個變量“隱藏”在壹個更大的作用域裏。但這種做法在Java裏是不允許的，因為Java的設計者認為這樣做使程序產生了混淆。
2.3.2 對象的作用域
Java對象不具備與主類型壹樣的存在時間。用new關鍵字創建壹個Java對象的時候，它會超出作用域的範圍之外。所以假若使用下面這段代碼：
{
String s = new String("a string");
} /* 作用域的終點 */
那麽句柄s會在作用域的終點處消失。然而，s指向的String對象依然占據著內存空間。在上面這段代碼裏，我們沒有辦法訪問對象，因為指向它的唯壹壹個句柄已超出了作用域的邊界。在後面的章節裏，大家還會繼續學習如何在程序運行期間傳遞和復制對象句柄。
這樣造成的結果便是：對於用new創建的對象，只要我們願意，它們就會壹直保留下去。這個編程問題在C和C++裏特別突出。看來在C++裏遇到的麻煩最大：由於不能從語言獲得任何幫助，所以在需要對象的時候，根本無法確定它們是否可用。而且更麻煩的是，在C++裏，壹旦工作完成，必須保證將對象清除。
這樣便帶來了壹個有趣的問題。假如Java讓對象依然故我，怎樣才能防止它們大量充斥內存，並最終造成程序的“凝固”呢。在C++裏，這個問題最令程序員頭痛。但Java以後，情況卻發生了改觀。Java有壹個特別的“垃圾收集器”，它會查找用new創建的所有對象，並辨別其中哪些不再被引用。隨後，它會自動釋放由那些閑置對象占據的內存，以便能由新對象使用。這意味著我們根本不必操心內存的回收問題。只需簡單地創建對象，壹旦不再需要它們，它們就會自動離去。這樣做可防止在C++裏很常見的壹個編程問題：由於程序員忘記釋放內存造成的“內存溢出”。
2.4 新建數據類型：類
如果說壹切東西都是對象，那麽用什麽決定壹個“類”（Class）的外觀與行為呢？換句話說，是什麽建立起了壹個對象的“類型”（Type）呢？大家可能猜想有壹個名為“type”的關鍵字。但從歷史看來，大多數面向對象的語言都用關鍵字“class”表達這樣壹個意思：“我準備告訴妳對象壹種新類型的外觀”。class關鍵字太常用了，以至於本書許多地方並沒有用粗體字或雙引號加以強調。在這個關鍵字的後面，應該跟隨新數據類型的名稱。例如：
class ATypeName {/*類主體置於這裏}
這樣就引入了壹種新類型，接下來便可用new創建這種類型的壹個新對象：
ATypeName a = new ATypeName();
在ATypeName裏，類主體只由壹條註釋構成（星號和斜杠以及其中的內容，本章後面還會詳細講述），所以並不能對它做太多的事情。事實上，除非為其定義了某些方法，否則根本不能指示它做任何事情。
2.4.1 字段和方法
定義壹個類時（我們在Java裏的全部工作就是定義類、制作那些類的對象以及將消息發給那些對象），可在自己的類裏設置兩種類型的元素：數據成員（有時也叫“字段”）以及成員函數（通常叫“方法”）。其中，數據成員是壹種對象（通過它的句柄與其通信），可以為任何類型。它也可以是主類型（並不是句柄）之壹。如果是指向對象的壹個句柄，則必須初始化那個句柄，用壹種名為“構建器”（第4章會對此詳述）的特殊函數將其與壹個實際對象連接起來（就象早先看到的那樣，使用new關鍵字）。但若是壹種主類型，則可在類定義位置直接初始化（正如後面會看到的那樣，句柄亦可在定義位置初始化）。
每個對象都為自己的數據成員保有存儲空間；數據成員不會在對象之間***享。下面是定義了壹些數據成員的類示例：
class DataOnly {
int i;
float f;
boolean b;
}
這個類並沒有做任何實質性的事情，但我們可創建壹個對象：
DataOnly d = new DataOnly();
可將值賦給數據成員，但首先必須知道如何引用壹個對象的成員。為達到引用對象成員的目的，首先要寫上對象句柄的名字，再跟隨壹個點號（句點），再跟隨對象內部成員的名字。即“對象句柄.成員”。例如：
d.i = 47;
d.f = 1.1f;
d.b = false;
壹個對象也可能包含了另壹個對象，而另壹個對象裏則包含了我們想修改的數據。對於這個問題，只需保持“連接句點”即可。例如：
myPlane.leftTank.capacity = 100;
除容納數據之外，DataOnly類再也不能做更多的事情，因為它沒有成員函數（方法）。為正確理解工作原理，首先必須知道“自變量”和“返回值”的概念。我們馬上就會詳加解釋。
1. 主成員的默認值
若某個主數據類型屬於壹個類成員，那麽即使不明確（顯式）進行初始化，也可以保證它們獲得壹個默認值。
主類型 默認值
Boolean false
Char '\u0000'(null)
byte (byte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d
壹旦將變量作為類成員使用，就要特別註意由Java分配的默認值。這樣做可保證主類型的成員變量肯定得到了初始化（C++不具備這壹功能），可有效遏止多種相關的編程錯誤。
然而，這種保證卻並不適用於“局部”變量——那些變量並非壹個類的字段。所以，假若在壹個函數定義中寫入下述代碼：
int x;
那麽x會得到壹些隨機值（這與C和C++是壹樣的），不會自動初始化成零。我們責任是在正式使用x前分配壹個適當的值。如果忘記，就會得到壹條編譯期錯誤，告訴我們變量可能尚未初始化。這種處理正是Java優於C++的表現之壹。許多C++編譯器會對變量未初始化發出警告，但在Java裏卻是錯誤。
2.5 方法、自變量和返回值
迄今為止，我們壹直用“函數”（Function）這個詞指代壹個已命名的子例程。但在Java裏，更常用的壹個詞卻是“方法”（Method），代表“完成某事的途徑”。盡管它們表達的實際是同壹個意思，但從現在開始，本書將壹直使用“方法”，而不是“函數”。
Java的“方法”決定了壹個對象能夠接收的消息。通過本節的學習，大家會知道方法的定義有多麽簡單！
方法的基本組成部分包括名字、自變量、返回類型以及主體。下面便是它最基本的形式：
返回類型 方法名( /* 自變量列表*/ ) {/* 方法主體 */}
返回類型是指調用方法之後返回的數值類型。顯然，方法名的作用是對具體的方法進行標識和引用。自變量列表列出了想傳遞給方法的信息類型和名稱。
Java的方法只能作為類的壹部分創建。只能針對某個對象調用壹個方法（註釋③），而且那個對象必須能夠執行那個方法調用。若試圖為壹個對象調用錯誤的方法，就會在編譯期得到壹條出錯消息。為壹個對象調用方法時，需要先列出對象的名字，在後面跟上壹個句點，再跟上方法名以及它的參數列表。亦即“對象名.方法名(自變量1，自變量2，自變量3...)。舉個例子來說，假設我們有壹個方法名叫f()，它沒有自變量，返回的是類型為int的壹個值。那麽，假設有壹個名為a的對象，可為其調用方法f()，則代碼如下：
int x = a.f();
返回值的類型必須兼容x的類型。
象這樣調用壹個方法的行動通常叫作“向對象發送壹條消息”。在上面的例子中，消息是f()，而對象是a。面向對象的程序設計通常簡單地歸納為“向對象發送消息”。
③：正如馬上就要學到的那樣，“靜態”方法可針對類調用，毋需壹個對象。
2.5.1 自變量列表
自變量列表規定了我們傳送給方法的是什麽信息。正如大家或許已猜到的那樣，這些信息——如同Java內其他任何東西——采用的都是對象的形式。因此，我們必須在自變量列表裏指定要傳遞的對象類型，以及每個對象的名字。正如在Java其他地方處理對象時壹樣，我們實際傳遞的是“句柄”（註釋④）。然而，句柄的類型必須正確。倘若希望自變量是壹個“字串”，那麽傳遞的必須是壹個字串。
④：對於前面提及的“特殊”數據類型boolean，char，byte，short，int，long，，float以及double來說是壹個例外。但在傳遞對象時，通常都是指傳遞指向對象的句柄。
下面讓我們考慮將壹個字串作為自變量使用的方法。下面列出的是定義代碼，必須將它置於壹個類定義裏，否則無法編譯：
int storage(String s) {
return s.length() * 2;
}
這個方法告訴我們需要多少字節才能容納壹個特定字串裏的信息（字串裏的每個字符都是16位，或者說2個字節、長整數，以便提供對Unicode字符的支持）。自變量的類型為String，而且叫作s。壹旦將s傳遞給方法，就可將它當作其他對象壹樣處理（可向其發送消息）。在這裏，我們調用的是length()方法，它是String的方法之壹。該方法返回的是壹個字串裏的字符數。
通過上面的例子，也可以了解return關鍵字的運用。它主要做兩件事情。首先，它意味著“離開方法，我已完工了”。其次，假設方法生成了壹個值，則那個值緊接在return語句的後面。在這種情況下，返回值是通過計算表達式“s.length()*2”而產生的。
可按自己的願望返回任意類型，但倘若不想返回任何東西，就可指示方法返回void（空）。下面列出壹些例子。
boolean flag() { return true; }
float naturalLogBase() { return 2.718; }
void nothing() { return; }
void nothing2() {}
若返回類型為void，則return關鍵字唯壹的作用就是退出方法。所以壹旦抵達方法末尾，該關鍵字便不需要了。可在任何地方從壹個方法返回。但假設已指定了壹種非void的返回類型，那麽無論從何地返回，編譯器都會確保我們返回的是正確的類型。
到此為止，大家或許已得到了這樣的壹個印象：壹個程序只是壹系列對象的集合，它們的方法將其他對象作為自己的自變量使用，而且將消息發給那些對象。這種說法大體正確，但通過以後的學習，大家還會知道如何在壹個方法裏作出決策，做壹些更細致的基層工作。至於這壹章，只需理解消息傳送就足le