前言

現在，假定已經成功地安裝了JDK，并且能夠運行第2章中給出的示例程序。從現在開始將介紹Java應用程序設計。本章主要講述程序設計相關的基本概念(如數據類型、分支以及循環)在Java中的實現方式。

非常遺憾，需要告誡大家，使用Java編寫GUI應用程序并不是一件很容易的事情，它需要編程者掌握很多相關的知識才能夠創建窗口、添加文本框和按鈕等。而基于GUI的Java應用程序設計技術與本章將要介紹的程序設計基本概念相差甚遠，因此在本章中給出的所有例子都是旨在說明一些相關概念而設計的“玩具式”程序，它們僅僅通過shell窗口輸入輸出。

最后需要說明，對于一個具有使用C++經驗的程序員來說，這一章的內容只需要瀏覽一下，應該重點閱讀分布在正文中的C/C++注釋。而對于具有使用Visual Basic等其他編程背景的程序員來說，可能會發現其中的絕大多數概念都很熟悉，只是在語法上有比較大的差異，因此，需要非常仔細地閱讀本章的內容。

一個簡單的Java應用程序

下面看一個最簡單的Java應用程序，它只發送一條消息到控制臺窗口中：

這個程序雖然很簡單，但因為所有的Java應用程序都具有這種結構，所以值得花一些時間對它進行研究。首先，Java對大小寫敏感。如果出現了大小寫拼寫錯誤(例如，將main拼寫成了Main)，程序就無法運行。

下面逐行地查看一下這段源代碼。關鍵字public被稱為訪問修飾符(access modifier)，它用于控制程序的其他部分對這段代碼的訪問級別。在第5章中將會更加詳細地介紹訪問修飾符的具體內容。關鍵字class表明Java程序中的全部內容都包含在類中。這里，只需要將類作為一個加載程序邏輯的容器，程序邏輯定義了應用程序的行為，在下一章中將會用大量的篇幅介紹Java類。

正如第1章所述，類是構建所有Java應用程序和applet的構建塊。Java應用程序中的全部內容都必須放置在類中。

關鍵字class后面緊跟類名。Java中定義類名的規則很寬松。名字必須以字母開頭，后面可以跟字母和數字的任意組合。長度基本上沒有限制。但是不能使用Java保留字(比如public或class)作為類名。(保留字列表請參閱附錄A。)

從類名FirstSample可以看出，標準的命名規范為：類名是以大寫字母開頭的名詞。如果名字由多個單詞組成，每個單詞的第一個字母都應該為大寫。(這種在一個單詞間使用大寫字母的方式被稱為“camel case”，以它自己為例，應該寫成“CamelCase”。)

源代碼的文件名必須與公有類的名字相同，并用.java作為擴展名。因此，存儲這段源代碼的文件名必須為FirstSample.java。(再次提醒大家注意，大小寫是非常重要的，千萬不能寫成firstsample.java。)

如果已經正確地命名了這個文件，并且源代碼中沒有任何錄入錯誤，那么在編譯這段源代碼之后，就會得到一個包含該類字節碼的文件。Java編譯器將字節碼文件自動地命名為FirstSample.class，并與源文件存儲在同一個目錄下。最后，使用下面這行命令運行這個程序：

java FirstSample

(請記住，不要添加.class擴展名。)程序執行之后，控制臺上將會顯示“We will not use

‘Hello,World’!”。

當使用

java ClassName

運行編譯程序時，Java虛擬機將從指定類中的main方法開始執行，因此為了代碼能夠得到執行，在類的源文件中必須包含一個main方法。當然，也可以把用戶自定義的方法添加到類中，并且在main方法中調用它們。(下一章，將講述如何自己定義方法。)

其解決方案放到網上讓所有人監督檢查，這是一種非常了不起的舉動。“bug 展示”對程序員來說是一種十分有用的資源，甚至程序員可以對感興趣的bug進行“投票”。得票多的bug在下一個將發行的版本的JDK中得到解決的可能性就大。

需要注意源代碼中的括號{ }。在Java中，像在C/C++中一樣，用花括號劃分程序的各個部分(通常稱為塊)。Java中任何方法的代碼都用“{”開始，用“}”結束。

花括號的使用風格曾經引發過許多無謂的爭論。我們的習慣是把匹配的花括號上下對齊。

不過，由于空白符會被Java編譯器忽略，所以自然可以選用任何自己喜歡的風格。在下面講述各種循環語句時，我們還會詳細地介紹花括號的使用。

我們暫且不去理睬關鍵字static void，而僅把它們當作編譯Java應用程序必需的一部分就行了。

學習完第4章，這些內容的作用就會被揭曉。現在需要記住：每個Java應用程序都必須有一個main方法，其格式如下所示：

接下來，讓我們研究一下這段代碼：

{System.out.println("We will not use 'Hello, World!'");}

一對花括號表示方法體的開始與結束，在這個方法中只包含一條語句。與大多數程序設計語言一樣，可以將Java語句看成是這種語言的句子。在Java中，每個句子必須用分號結束。特別要說明一點，回車不是語句的結束標志，因此，如果需要可以將一條語句寫在多行上。

在上面這個main方法體中只包含了一條語句，其功能是：將一個文本行輸出到控制臺上。

在這里，使用了System.out對象并調用了它的println方法。注意，點號用來調用一個方法。

Java使用的通用語法是

object.method( parameters)

這等價于函數調用。

在這個例子中，調用了println方法并傳遞給它一個字符串參數。這個方法將傳遞給它的字符串參數顯示在控制臺上。然后，終止這個輸出行，以便每次調用println都會在新的一行上顯示輸出。需要注意一點，Java與C/C++一樣，都采用雙引號分隔字符串。本章稍后將會詳細地講解有關字符串的知識。

與其他程序設計語言一樣，在Java的方法中，可以沒有參數，也可以有零個、一個或多個參數。(有的程序員把參數叫做變元。)對于一個方法，即使沒有參數也需要書寫圓括號。例如，不帶參數的println方法只打印一個空行。使用下面的語句：

System.out.println( );

注釋

與大多數程序設計語言一樣，Java中的注釋也不會出現在可執行程序中。因此，可以在源程序中添加任意多的注釋，而不必擔心可執行代碼會膨脹。在Java中，有三種表示注釋的方式。最常用的方式是使用 //，其注釋內容從 // 開始到本行結尾。

System.out.println("We will not use 'Hello, World!'"); //is this too cute?

當需要比較長的注釋時，可以在每行的注釋前面標記 //，也可以使用 /* 和 */ 將一段比較長的注釋括起來。請參看例3-1。

例3-1 FirstSample.java

第三種注釋可以用來自動地生成文檔。這種注釋以 /**開始，以 */ 結束。有關這種注釋的詳細內容和自動生成文檔的具體方法請參閱第4章。

數據類型

Java是一種強類型語言(strongly typed language)。這就意味著必須為每一個變量聲明一種類型。在Java中，一共有8種基本類型(primitive type)，其中有4個整型、2個浮點類型、1個用于表示Unicode編碼的字符單元的字符類型char(請參見論述char類型的章節)和1個用于表示真值的boolean類型。

整型

整型用于表示沒有小數部分的數值，它允許是負數。Java提供了4種整型，具體內容如表3-1所示。

在通常情況下，int類型非常有用，但要表示星球上的居住人數，就要使用long類型了。byte和short類型主要用于特定的場合，例如，底層的文件處理或者需要控制占用存儲空間量的大數組。

在Java中，整型的范圍與運行Java代碼的機器無關。這就解決了軟件從一個平臺移植到另一個平臺，或者在同一個平臺中的不同操作系統之間進行移植給程序員帶來的諸多問題。與此相反，C和C++程序需要針對不同的處理器選擇最為有效的整型，這樣就有可能造成一個在32位處理器上運行很好的C程序在16位系統上運行卻發生整數溢出。由于Java程序必須保證在所有機器上都能夠得到相同的運行結果，所以每一種數據類型的取值范圍必須固定。

長整型數值有一個后綴L(如4000000000L)。十六進制數值有一個前綴0x(如0xCAFE)。八進制有一個前綴0，例如，010對應八進制中的8。很顯然，八進制表示法比較容易混淆，所以建議最好不要使用八進制常數。

浮點型

浮點類型用于表示有小數部分的數值。在Java中有兩種浮點類型，具體內容如表3-2所示。

double表示這種類型的數值精度是float類型的兩倍。(有人稱之為雙精度。)絕大部分應用程序都采用double類型。在很多情況下，float類型的精度很難滿足需求。例如，用7位有效數字足以精確表示普通雇員的年薪，但表示公司總裁的年薪可能就不夠用了。實際上，只有很少的情況適合使用float類型，例如，需要快速地處理單精度數據，或者需要存儲大量數據。

float類型的數值有一個后綴F(例如，3.402F)。沒有后綴F的浮點數值(如3.402)默認為double類型。當然，也可以在浮點數值后面添加后綴D(例如，3.402D)。

在JDK 5.0中，可以使用十六進制表示浮點數值。例如，0.125可以表示成0x1.0p-3。在十六進制表示法中，使用p表示指數，而不是e。

所有的浮點數值計算都遵循IEEE 754規范。下面是三個特殊的浮點數值：

? 正無窮大

? 負無窮大

? NaN

上面這三個數值用于表示溢出和出錯情況。例如，一個正整數除以0的結果為正無窮大。計算0/0或者負數的平方根結果為NaN。

char類型

要想弄清char類型，就必須了解Unicode編碼表。Unicode打破了傳統字符編碼方法的限制。在Unicode出現之前，已經有許多種不同的標準：美國的ASCII、西歐語言中的ISO 8859-1、俄國的KOI-8、中國的GB118030和BIG-5等等。這樣就產生了下面兩個問題：一個是對于任意給定的代碼值，在不同的編碼方案下有可能對應不同的字母；二是采用大字符集的語言其編碼長度有可能不同。例如，有些常用的字符采用單字節編碼，而另一些字符則需要兩個或更多個字節。

設計Unicode編碼就是要解決這些問題。在20世紀80年代開始啟動設計工作時，人們認為兩個字節的代碼寬度足以能夠將世界上各種語言的所有字符進行編碼，并有足夠的空間留給未來的擴展。在1991年發布了Unicode 1.0，當時僅占用65 536個代碼值的一小部分。在設計Java時決定采用16位的Unicode字符集，這樣會比使用8位字符集的程序設計語言有很大的改進。

十分遺憾，經過一段時間，不可避免的事情發生了。Unicode字符超過了65 536個，其主要原因是添加了大量的漢語、日語和韓國語言中的表意文字。現在，16位的char類型已經不能滿足描述所有Unicode字符的需要了。

下面利用一些專用術語解釋一下Java語言解決這個問題的基本方法。從JDK 5.0開始。代碼點(code point)是指與一個編碼表中的某個字符對應的代碼值。在Unicode標準中，代碼點采用十六進制書寫，并加上前綴U+，例如U+0041就是字母A的代碼點。Unicode的代碼點可以分成17個代碼級別(code plane)。第一個代碼級別稱為基本的多語言級別(basic multilingual plane)，代碼點從U+0000到U+FFFF，其中包括了經典的Unicode代碼；其余的16個附加級別，代碼點從U+10000到U+10FFFF，其中包括了一些輔助字符(supplementary character)。

UTF-16編碼采用不同長度的編碼表示所有Unicode代碼點。在基本的多語言級別中，每個字符用16位表示，通常被稱為代碼單元(code unit)；而輔助字符采用一對連續的代碼單元進行編碼。這樣構成的編碼值一定落入基本的多語言級別中空閑的2048字節內，通常被稱為替代區域(surrogate area)(U+D800到U+DBFF用于第一個代碼單元，U+DC00到U+DFFF用于第二個代碼單元)。這種設計十分巧妙，我們可以從中迅速地知道一個代碼單元是一個字符的編碼，還是一個輔助字符的第一或第二部分。例如，對于整數集合的數學符號 ，它的代碼點是U+1D56B，并且是用兩個代碼單元U+D835和U+DD6B編碼的。(有關編碼算法的描述請參閱http://en.wikipedia.org/wiki/UTF-16。)

在Java中，char類型用UTF-16編碼描述一個代碼單元。

我們強烈建議不要在程序中使用char類型，除非確實需要對UTF-16代碼單元進行操作。最好將需要處理的字符串用抽象數據類型表示。(有關這方面的內容將在稍后討論。)

前面已經說過，在有些情況下，可能需要用到char的值。最常見的情況是字符常量。例如，'A'是一個編碼為65的字符常量，它與"A"完全不同，是一個包含字符A的字符串。Unicode代碼單元可以表示為十六進制的值，其范圍從 到。例如，?是注冊符號(?)；π是希臘字母π。

除了可以采用轉義序列符u表示Unicode代碼單元的編碼之外，還有一些用于表示特殊字符的轉義序列符，請參看表3-3。所有這些轉義序列符都可以出現在字符常量或字符串的引號內。

例如，'?'或"Hello"。轉義序列符u還可以出現在字符常量或字符串的引號之外(而其他所有轉義序列不可以)。例如：

public static void main (String[] args)

這種形式完全符合語法規則，[和 ] 是 [ 和 ] 的Unicode代碼點的UTF-16編碼。

boolean類型

boolean(布爾)類型有兩個值：false和true，用來判定邏輯條件。這兩個值不能與整型進行相互轉換。

變量

在Java中，每一個變量屬于一種類型(type)。在聲明變量時，變量所屬的類型位于前面，隨后是變量名。這里列舉一些聲明變量的例子：

double salary;

int vacationDays;

long earthPopulation;

boolean done;

注意，用于Java中，聲明是一條完整的語句，因此每一個聲明都必須以分號結束。

變量名必須是一個以字母開頭的字母或數字序列。需要注意，與大多數程序設計語言相比，Java中“字母”和“數字”的范圍要大。字母包括'A'～'Z'、'a'～'z'、'_'和在某種語言中代表字母的任何Unicode字符。例如，德國的用戶可以在變量名中使用字母'?'；希臘人可以使用π。同樣，數字包括'0'～'9'和在某種語言中代表數字的任何Unicode字符。但'+'和'?'這樣的符號不能出現在變量名中，空格也不行。變量名中所有的字符都是有意義的，并且大小寫敏感。對變量名的長度沒有限制。

另外，不能將變量名命名為Java保留字。(請參看附錄A中的Java保留字列表。)

可以在一行中聲明多個變量：

int i, j; //both are integers

不過，不提倡使用這種風格。逐一聲明每一個變量可以提高程序的可讀性。

初始化變量

聲明一個變量之后，必須利用賦值語句對變量進行顯式初始化，千萬不要使用一個未被初始化的變量。例如，Java編譯器認為下面語句序列是錯誤的：

int vacationDays;

System.out.println(vacationDays); //ERROR-variable not initialized

要想對一個已經聲明過的變量進行賦值，就需要將變量名放在等號(＝)左側，具有相應取值的Java表達式放在等號的右側。

int vacationDays;

vacationDays = 12;

也可以將變量的聲明和初始化放在同一行中。例如：

int vacationDays = 12;

最后，在Java中可以將聲明放在代碼中的任何地方。例如，在Java中，下列代碼的書寫形式是完全合法的：

double salary = 65000.0;

System.out.println(salary);

int vacationDays = 12; // ok to declare a variable here

在Java中，變量的聲明盡可能地靠近變量第一次使用的地方，這是一種良好的程序編寫風格。

extern int i;

是聲明一個變量。在Java中，不區分變量的聲明與定義。

常量

在Java中，利用關鍵字final聲明常量。例如：

關鍵字final表示這個變量只能被賦值一次。一旦被賦值之后，就不能夠再更改了。習慣上，常量名使用大寫。

在Java中，經常希望某個常量可以在一個類中的多個方法中使用，通常將這些常量稱為類常量。可以使用關鍵字static final設置一個類常量。下面是使用類常量的例子：

需要注意，類常量的定義位于main方法的外部。因此，在同一個類的其他方法中也可以使用這個常量。而且，如果一個常量被聲明為public，那么其他類的方法也可以使用這個常量。在這個例子中，Constants2.CM_PER-INCH就是這樣一個常量。

運算符

在Java中，使用算術運算符＋、－、*、/ 表示加、減、乘、除運算。當參與 / 運算的兩個操作數都是整數時，表示整數除法；否則，表示浮點除法。整數的求余操作(有時稱為取模)用%表示。例如，15/2等于7，15%2等于1，15.0/2等于7.5。

需要注意，整數被0除將會產生一個異常，而浮點數被0除將會得到無窮大或NaN。

可以在賦值語句中采用簡化的格式書寫二元算術運算符。

例如，

x += 4;

等價于

x = x + 4;

(通常，將運算符放在賦值號的左側，如*= 或 %=。)

自增運算符與自減運算符

當然，程序員都知道加1、減1是數值變量最常見的操作。在Java中，借鑒了C和C++的實現方式，也使用了自增、自減運算符：n++將變量n的當前值加1；n--將n的值減1。例如：

int n =12;

n++;

n的值將變為13。因為這些運算符改變了變量的值，所以它的操作數不能是數值。例如，4++就是一條非法的語句。

實際上，這兩個運算符有兩種形式。上面介紹的是運算符放在后面的“后綴”形式，還有一種“前綴”形式(++n)都是對變量值加1。但在表達式中，這兩種形式就有區別了。前綴方式先進行加1運算；后綴方式則使用變量原來的值。

int m = 7;

int n = 7;

int a = 2 * ++m;//now a is 16, m is 8

int b = 2 * n++;//now b is 14, n is 8

我們建議不要在其他表達式的內部使用++，這樣編寫的代碼很容易令人感到迷惑，并會產生煩人的bug。

顯然，++ 運算符構成了C++語言名稱，這也引發了有關程序設計語言的第一個笑話。C++的反對者認為這種語言的名稱也存在著bug，他們說：“因為只有對它改進之后，我們才有可能使用它，所以它的名字應該命名為++C。”

關系運算符與boolean運算符

Java具有各種關系運算符。其中，使用兩個等號 = = 檢測是否相等。例如，3 = = 7的值為false。

使用 != 檢測是否不相等。例如，3 != 7的值為true。

另外，經常使用的運算符還有 (大于)、<=(小于等于)和>=(大于等于)。

Java沿用了C++的習慣，用&&表示邏輯“與”、用 || 表示邏輯“或”。從!= 運算符很容易看出，!表示邏輯“非”。&&和 || 是按照“短路”方式求值的。如果第一個操作數已經能夠確定值，第二個操作數就不必計算了。如果用 && 對兩個表達式(expression)進行計算：

expression1 && expression2

并且第一個表達式值為false，那么結果不可能為真。因此，第二個表達式就沒有必要計算了。這種方式可以避免一些錯誤的發生。例如，表達式：

x != 0 && 1 / x > x + y // no division by 0

當x為0時，不計算第二部分，因此1 / x不被計算也不會出現除以0的錯誤。

與之類似，對于expression1 || expression2 ，當第一個表達式為true時，結果自動為true，不必再計算第二部分。

最后，Java支持三元操作?:，在很多時候，這個操作非常有用。表達式

condition ? expression1 : expression2

當條件為真時計算第1個表達式，否則計算第2個表達式。

例如：

x < y ? x : y

返回x和y中較小的那個值。

位運算符

在處理整型數值時，可以直接對組成整型數值的各個位進行操作。這意味著可以使用屏蔽技術獲得整數中的各個位。位運算符包括：

&(“與”)、|(“或”)、^(“異或”)、~(“非”)

這些運算符在位模式下工作。例如，如果n是一個整型變量，并且用二進制表示的n從右數第4位為1，那么

int fourthBitFromRight = (n & 8) / 8;

返回1；否則返回0。通過使用2的冪次方和&運算可以將其他位屏蔽掉，而只保留其中的某一位。

數學函數與常量

在Math類中，包含了各種各樣的數學函數。在編寫不同類別的程序時，可能需要的函數也不同。

要想計算一個數值的平方根，可以使用sqrt方法：

double x = 4;double y = Math.sqrt(x);System.out.println(y); //prints 2.0

在Java中，沒有冪運算。因此求冪需要借助于Math類的pow方法。語句：

double y = Math.pow(x, a) ;

將y的值設置為x的a次方(xa)。pow方法有兩個double類型的參數，其返回結果也為double類型。

Math類提供了一些常用的三角函數：

Math.sin

Math.cos

Math.tan

Math.atan

Math.atan2

還有指數函數以及它的反函數—自然對數：

Math.exp

Math.log

最后，Java還提供了兩個用于表示π和e常量的近似值：

Math.PI

Math.E

數值類型之間的轉換

在程序運行時，經常需要將一種數值類型轉換為另一種數值類型。圖3-1給出了數值類型之間的合法轉換。

圖3-1 數值類型之間的合法轉換

在圖3-1中有6個實箭頭，表示無數據丟失的轉換；有3個虛箭頭，表示可能有精度損失的轉換。例如，123 456 789是一個大整數，它所包含的位數比float類型所能夠表達的位數多。當將這個整型數值轉換為float類型時，將會得到同樣大小的結果，但卻失去了一定的精度。

int n = 123456789;

float f = n; // f is 1.23456792E8

當使用上面兩個數值進行二元操作時(例如n + f，n是整數，f是浮點數)，先要將兩個操作數轉換為同一種類型，然后再進行計算。

? 如果兩個操作數中有一個是double類型的，那么另一個操作數將會轉換為double類型。

? 否則，如果其中一個操作數是float類型，那么另一個操作數將會轉換為float類型。

? 否則，如果其中一個操作數是long類型，那么另一個操作數將會轉換為long類型。

? 否則，兩個操作數都將被轉換為int類型。

強制類型轉換

在上一小節中看到，在必要的時候，int類型的值將會自動地轉換為double類型。但另一方面，有時也需要將double轉換成int。在Java中，允許進行這種數值之間的類型轉換，當然，有可能會丟失一些信息。在這種情況下，需要通過強制類型轉換(cast)實現這個操作。

強制類型轉換的語法格式是在圓括號中給出想要轉換的目標類型，隨后緊跟待轉換的變量名。

例如：

double x = 9.997;

int nx = (int)x;

這樣，變量nx的值為9。強制類型轉換將通過截斷小數部分來把一個浮點值轉換為整型。

如果想對浮點數進行舍入運算，得到最接近的整數(在很多情況下，希望使用這種操作方式)，就需要使用Math.round方法：

double x = 9.997;

int nx = (int) Math.round (x);

現在，變量nx的值為10。當調用round的時候，仍然需要使用強制類型轉換(int)。其原因是round方法返回的結果為long類型，由于存在信息丟失的可能性，所以只有使用顯示的強制類型轉換才能夠將long類型轉換成int類型。

括號與運算符級別

表3-4給出了運算符的優先級。如果不使用圓括號，就按照給出的運算符優先級次序進行計算。同一個級別的運算符按照從左到右的次序進行計算(除了表中給出的右結合運算符之外。)

例如，由于 && 的優先級比 || 的優先級高，所以表達式

a && b || c

等價于

( a && b ) || c

又因為 += 是右結合運算符，所以表達式

a += b += c

等價于

a += ( b += c )

也就是將b += c 的結果(加上c之后的b)加到a上。

枚舉類型

有些時候，變量的取值僅在一個有限的集合內。例如：銷售的服裝或比薩餅只有小、中、大和超大這四種尺寸。當然，可以將這些尺寸編碼為1、2、3、4或S、M、L、X。但這樣做存在著一定的隱患。在變量中很可能保存的是一個錯誤的值(如0或m)。

從JDK 5.0開始，針對這種情況，可以自定義枚舉類型。枚舉類型包括有限個命名的值。例如，enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE };

現在，可以聲明這樣一種類型的變量：

Size s = Size.MEDIUM;

Size類型的變量只能存儲該類型聲明中給定的某個枚舉值，或者null值。

有關枚舉類型的詳細內容將在第5章介紹。

字符串

從概念上講，Java字符串就是Unicode字符序列。例如，串“Java?”由5個Unicode字符J、a、v、a和?組成。Java 沒有內置的字符串類型，而是在標準Java類庫中提供了一個預定義類String。每個用雙引號括起來的字符串都是String類的一個實例：

String e = ""; //an empty string

String greeting = "Hello";

3.6.1 代碼點與代碼單元

Java字符串由char值序列組成。從前面已經看到，char數據類型是一個采用UTF-16編碼表示Unicode代碼點的代碼單元。大多數的常用Unicode字符使用一個代碼單元就可以表示，而輔助字符需要一對代碼單元表示。

length方法將返回采用UTF-16編碼表示的給定字符串所需要的代碼單元數量。例如：

String greeting = "Hello";

int n = greeting.length( ); // is 5.

要想得到實際的長度，即代碼點數量，可以調用：

int cpCount = greeting.codePointCount(0,greeting.length( ));

調用s.charAt(n) 將返回位置n的代碼單元，n介于0 ~ s.length( )-1之間。例如：

char first = greeting.charAt(0); //first is 'H'

char last = greeting.charAt(4); //last is 'o'

要想得到第i個代碼點，應該使用下列語句

int index = greeting.offsetByCodePoints(0,i);

int cp = greeting.codePointAt(index);

為什么我們對代碼單元大驚小怪？請考慮下列語句：

is the set of integers

使用UTF-16編碼表示 需要兩個代碼單元。調用

char ch = sentence.charAt(1)

返回的不是空格，而是 的第二個代碼單元。為了避免這種情況的發生，請不要使用char類型。這太低級了。

如果想要遍歷一個字符串，并且依次查看每一個代碼點，可以使用下列語句：

int cp = sentence.codePointAt(i);

if (Character.isSupplementaryCodePoint(cp)) i += 2;

else i++;

非常幸運，codePointAt方法能夠辨別一個代碼單元是輔助字符的第一部分還是第二部分，并能夠返回正確的結果。也就是說，可以使用下列語句實現回退操作：

i--;

int cp = sentence.codePointAt(i);

if (Character.isSupplementaryCodePoint(cp)) i--;

子串

String類的substring方法可以從一個較大的字符串提取出一個子串。例如：

String greeting = "Hello";

String s = greeting.substring(0, 3);

創建了一個由字符“Hel”組成的字符串。

substring的第二個參數是不希望復制的第一個代碼單元。這里復制的代碼單元位置為0、1、2(從0到2，包括0和2)。在substring中的計數是從0～3。

substring的工作方式有一個優點：容易計算子串中代碼單元的數量。字符串s.substring(a, b) 將包含b-a個代碼單元。例如，子串“Hel”的代碼單元數量為3－0＝3。

字符串編輯

String類沒有提供用于修改現存字符串的方法。如果希望將greeting的內容修改為“Help!”，不能直接地將greeting的最后兩個位置的字符修改為'p'和'!'。這對于一個C 程序員來說會感到無從下手。如何修改這個字符串呢？在Java中實現這項操作相當容易，首先提取需要的子串，然后再拼接上需要替換的字符串。

greeting = greeting.substring(0,3) + "p!";

上面這條語句將greeting當前值修改為“Help！”。

由于不能修改Java字符串中的字符，所以在Java文檔中將String類對象稱為不可變字符串，如同數字3永遠是數字3一樣，字符串“Hello”永遠包含H、e、l、l和o的代碼單元序列，而不能修改其中的任何一個字符。當然，可以修改字符串變量greeting的內容，讓它引用一個不同的字符串，如同可以將一個存放3的數值變量改成存放4一樣。

這樣做是否會降低運行效率呢？看起來好象修改一個代碼單元要比創建一個新字符串更加簡潔。答案是：也對，也不對。的確，通過拼接“Hel”和“p!”來創建一個新字符串的效率確實不高。但是，不可變字符串卻有一個優點：編譯器可以將字符串共享。

要想了解具體的工作方式，可以想象將各種字符串存放在公共的存儲池中。字符串變量指向存儲池中相應的位置。如果復制一個字符串變量，那么原始字符串與復制的字符串共享相同的字符。總而言之，Java的設計者認為共享帶來的高效率遠遠勝過于提取子串，然后再拼接字符串所帶來的低效率。

查看一下程序會發現：不會經常修改字符串，而是對字符串進行比較。當然，在有些情況下，直接對字符串進行操作會更加有效。(例如，將源自文件或鍵盤的單個字符匯集成字符串。)

為此Java提供了一個獨立的StringBuilder類，在第12章中將詳細地闡述它。如果不太注重字符串的處理效率，就可以不理會StringBuilder，而只使用String。

拼接

與絕大多數的程序設計語言一樣，Java語言允許使用 + 號連接(拼接)兩個字符串。

String expletive = "Expletive";

String PG13 = "deleted";

String message = expletive + PG13;

上面的代碼將“Expletivedeleted”賦給變量message。(注意，單詞之間沒有空格，+號按照給定的次序將兩個字符串拼接起來。)

當將一個字符串與一個非字符串的值進行拼接時，后者被轉換成字符串。(在第5章中可以看到，任何一個Java對象都可以轉換成字符串。)例如：

int age = 13;

String rating = "PG" + age;

rating得到“PG13”。

這種特性通常用在輸出語句中。例如，

System.out.println ("The answer is" + answer);

這是一條合法的語句，并且將會打印出所希望的結果(單詞is后面加了一個空格，輸出時也會加上這個空格。)

檢測字符串是否相等

可以使用equals方法檢測兩個字符串是否相等。如果字符串s與字符串t相等，則表達式s.equals(t)返回true；否則，返回false。需要注意，s與t可以是字符串變量，也可以是字符串常量。

例如，表達式

"Hello".equals(greeting)

是合法的。要想檢測兩個字符串是否相等，而不區分大小寫，可以使用equalsIgnoreCase方法。

"Hello".equalsIgnoreCase("hello")

一定不能使用 = = 運算符檢測兩個字符串是否相等！這個運算符只能夠確定兩個字符串是否被放置在同一個位置。當然，如果字符串放置在同一個位置，它們必然相等。但是，完全有可能將內容相同的兩個字符串放置在不同的位置上。

String greeting = "Hello"; //initialize greeting to a string

if (greeting = = "Hello") ...

// probably true

if (greeting.substring(0, 3) = = "Hel")...

//probably false

如果虛擬機總是將相同的字符串共享，就可以使用 == 運算符檢測是否相等。但實際上只有字符串常量是共享的，而+或substring等操作產生的結果都不是共享的。因此，永遠不要使用 ==運算符測試字符串的相等性，否則在程序中會出現很糟糕的bug，從表面上看很像隨機產生的間歇性錯誤。

Java中的String類包含了50多個方法。令人驚訝的是絕大多數都很有用，可以想象使用的機會有多么頻繁。下面的API注釋匯總了最常用的部分方法。

java.lang.string 1.0

? char charAt (int index)

返回指定位置的代碼單元。除非對底層的代碼單元感興趣，否則不需要調用這個方法。

? int codePointAt(int index) 5.0

返回從給定位置開始或結束的代碼點。

? int offsetByCodePoints(int startIndex, int cpCount) 5.0

返回從startIndex代碼點開始，位移cpCount后的代碼點索引。

? int compareTo(String other)

按照字典順序，如果字符串位于other之前，則返回一個負數；如果字符串位于other之后，則返回一個正數；如果兩個字符串相等，則返回0。

? boolean endsWith(String suffix)

如果字符串以suffix結尾，則返回true。

? boolean equals(Object other)

如果字符串與other相等，則返回true。

? boolean equalsIgnoreCase(String other)

如果字符串與other相等(忽略大小寫)，則返回true。

? int index0f(String str)

? int index0f(String str, int fromIndex)

? int index0f(int cp)

? int index0f(int cp, int fromIndex)

返回與字符串str或代碼點cp匹配的的第一個子串的開始位置，該位置從索引0或fromIndex開始計算。如果在原始串中不存在str，則返回－1。

? int lastIndex0f(String str)

? int lastIndex0f(String str, int fromIndex)

? int lastindex0f(int cp)

? int lastindex0f(int cp, int fromIndex)

返回與字符串str或代碼點cp匹配的最后一個子串的開始位置，該位置從原始串尾端或

fromIndex開始計算。

? int length( )

返回字符串的長度。

? int codePointCount(int startIndex, int endIndex) 5.0

返回startIndex和endIndex-1之間的代碼點數量。沒有配成對的替代字符作為代碼點計數。

? String replace(CharSequence oldString,CharSequence newString)

返回一個新字符串，該字符串用newString代替原始字符串中所有的oldString。可以用String或

StringBuilder對象作為CharSequence參數。

? boolean startsWith(String prefix)

如果字符串以preffix字符串開始，則返回true。

? String substring(int beginIndex)

? String substring(int beginIndex, int endIndex)

返回一個新字符串，該串包含從原始字符串beginIndex到串尾或endIndex-1的所有代碼單元。

? String toLowerCase( )

返回一個新字符串，該串將原始字符串中的所有大寫字母改成了小寫字母。

? String toUpperCase( )

返回一個新字符串，該串將原始字符串中的所有小寫字母改成了大寫字母。

? String trim( )

返回一個新字符串，該串刪除了原始字符串頭部和尾部的空格。

閱讀聯機API文檔

正如前面所看到的，String類包含許多方法。而且，在標準庫中有幾千個類，方法數量則更加驚人。要想記住所有的類和方法是一件不太不可能的事情。因此，了解在線API文檔十分重要，從中可以查閱到標準類庫中的所有類和方法。API文檔是JDK的一部分，它是HTML格式的。讓瀏覽器指向安裝JDK的docs/api/index.html子目錄，就可以看到如圖3-2所示的屏幕。

可以看到，屏幕被分成三個窗框。在左上方的小窗框中顯示了可使用的所有包。在它下面稍大的窗框中列出了所有的類。點擊任何一個類名之后，該類的API文檔就會顯示在右側的大窗框中(請參看圖3-3)。例如，要獲得有關String類方法的更多信息，可以滾動第二個窗框，直到看見String鏈接為止，然后點擊這個鏈接。

然后，滾動右面的窗框，直到看見按字母順序排列的所有方法為止(請參看圖3-4)。點擊任何一個方法名便可以查看這個方法的詳細描述(參見圖3-5)。例如，如果點擊compare-ToIgnoreCase鏈接，就會看到compareToIgnoreCase方法的描述。

輸入輸出

為了增加后面例子程序的趣味性，需要程序能夠接收輸入，并以適當的格式輸出。當然，現代的程序都使用GUI收集用戶的輸入，編寫這種界面的程序需要使用較多的工具與技術，目前還不具備這些條件。主要原因是需要熟悉Java程序設計語言，因此只要有簡單的用于輸入輸出的控制臺就可以了。第7章～第9章將詳細地介紹GUI程序設計。

讀取輸入

前面已經看到，打印輸出到“標準輸出流”(即控制臺窗口)是一件非常容易的事情，只要調用System.out.println即可。而在JDK 5.0之前卻沒有從控制臺窗口讀取輸入的簡便方法。值得慶賀的是，這一狀況終于得到了改變。

要想通過控制臺進行輸入，首先需要構造一個Scanner對象，它附屬于“標準輸入流”System.in。

Scanner in = new Scanner(System.in);

現在，就可以使用Scanner類的各種方法實現輸入操作了。例如，nextLine方法將輸入一行。

System.out.print("What is your name?");

String name = in.nextLine( );

在這里，使用nextLine方法的主要原因是在輸入行中可能包含空格。如果讀取的是一個單詞(以空白符作為分隔符)，則可以調用

String firstName = in.next( );

要想讀取一個整數，可以使用nextInt方法。

System.out.print("How old are you?");

int age = in.nextInt( );

與此類似，要想讀取下一個浮點數，可以使用nextDouble方法。

在例3-2的程序中，詢問用戶姓名和年齡，然后打印一條如下格式的消息：

Hello, Cay. Next year, you’ll be 46

最后，在程序的最開始添加上一行：

import java.util.* ;

Scanner類定義在java.util包中。當使用的類不是定義在基本java.lang包中時，一定要使用import指示字將相應的包加載進來。有關包與import指示字的詳細描述請參看第4章。

例3-2 InputTest.java

String input = JOptionPane.showInputDialog(promptString)它的返回值是用戶輸入的字符串。

例如，可以這樣詢問用戶的名字：

String name = JOptionPane.showInputDialog("What is your name?");

如果想要輸入數值，還需要附加一步操作。

JOptionPane.showInputDialog方法返回一個字符串，而不是一個數值。不過可以使用Integer.parseInt或Double.parseDouble方法將字符串轉換成數值。例如，String input = JOptionPane.showInputDialog("How old are you?");

int age = Integer.parseInt(input);

如果用戶鍵入了45，字符串變量input將得到字符串“45”，然后調用Integer.parseInt方法將這個字符轉換為數值45。

JOptionPane類定義在javax.swing包中，因此，需要添加語句：

import javax.swing.*;

最后，需要說明一點，當程序調用JOptionPane.showInputDialog時，需要通過調用System.exit(0)結束應用程序。這主要是技術上的原因。當顯示一個對話框時，就啟動了一個新的控制線程。在main方法退出后，新線程并沒有自動地終止。要想終止所有的線程，需要調用System.exit方法。(關于線程的詳細論述請參見本書卷II第1章。)下面這段程序應用于JDK 5.0之前的版本，它的功能與例3-2一樣。

java.util.Scanner 5.0

? Scanner (InputStream in)

用指定的輸入流創建一個Scanner對象。

? String nextLine( )

讀取輸入的下一行內容。

? String next( )

讀取輸入的下一個單詞(以空格作為分隔符)。

? int nextInt( )

? double nextDouble( )

讀取并轉換下一個表示整數或浮點數的字符序列。

? boolean hasNext( )

檢測輸入中是否還有單詞。

? boolean hasNextInt( )

? boolean hasNextDouble( )

檢測是否還有表示整數或浮點數的下一個字符序列。

javax.swing.JOptionPane 1.2

? static String showInputDialog(Object message)

顯示一個對話框，帶有信息提示、一個輸入框和“OK”、“Cancel”按鈕。這個方法將返回用戶輸入的字符串。

java.lang.System 1.0

? static void exit(int status)

終止虛擬機并將狀態碼傳遞給操作系統。習慣上，非0的狀態碼表示出錯。

格式化輸出

可以使用System.out.print(x) 將數值x輸出到控制臺上。這條命令將以x對應的數據類型所允許的最大非0數字位數打印輸出x。例如:

double x = 10000.0 / 3.0;

System.out.print(x);

打印

3333.3333333333335

如果希望顯示美元、美分等符號，有可能會出現問題。

在JDK 5.0之前，格式化數值曾引起過一些爭議。現在，JDK 5.0沿用了C語言庫函數中的printf方法。例如，調用

System.out.printf("%8.2f", x);

可以用8個字符的寬度和小數點后兩位的精度打印x。也就是說，打印輸出一個空格和7個字符，如下所示：

3333.33

在printf中，可以使用多個參數，例如：

System.out.printf("Hello, %s. Next year, you’ll be %d", name, age);

每一個以%字符開始的格式說明符都用相應的參數替換。格式說明符結尾的轉換符將指示被格式化的數值類型：f表示浮點數，s表示串，d表示十進制整數。表3-5給出了所有轉換符。

另外，還可以給出控制格式化輸出的各種標志。表3-6給出了所有的標志。例如，逗號標志添加了分組的分隔符。即

System.out.printf("%, .2f", 10000.0 / 3.0);

打印

3,333.33

可以使用多個標志，例如，“%, ( .2f”，使用分組的分隔符并將負數括在括號內。

可以使用靜態的String.format方法創建一個格式化的字符串，而不打印輸出：

String message = String.format("Hello, %s. Next year, you’ll be %d", name, age);

盡管在第4章之前，并沒有對Date類型進行詳細描述，但基于完整性的考慮，這里簡略地討論一下printf方法的日期與時間的格式化選項。可以使用兩個字符的格式，以t開始，以表3-7中任意字母結束。例如，

System.out.printf("%tc", new Date( ));

這條語句將用下面的格式打印當前的日期和時間：

Mon Feb 09 18:05:19 PST 2004

從表3-7可以看到，某些格式只給出了給定日期的一部分信息。例如，只有日期或只有月份。

如果需要多次對日期操作才能實現對每一部分格式化的目的就太笨拙了。為此，可以采用一個格式化的字符串指出要被格式化的參數索引。索引必須緊跟在%后面，并以$終止。例如，System.out.printf("%1$s %2$tB %2$te, %2$tY", "Due date:", new Date( ));

打印

Due date: February 9, 2004

作為替代方案，還可以使用 < 標志。它指出前面格式說明中的參數要再次使用。也就是說，下列語句將產生與前面語句同樣的輸出結果。

System.out.printf("%s %tB %

現在，已經了解了printf方法的所有特性。圖3-7給出了格式說明符的語法圖。

控制流程

與任何程序設計語言一樣，Java使用條件語句和循環來確定控制流程。在本節中，先討論條件語句，然后再討論循環語句，最后再介紹顯得有些笨重的switch語句。當需要對某個表達式的多個值進行檢測時，可以使用switch語句。

塊作用域

在深入學習控制結構之前，需要了解塊(block)的概念。

塊(即復合語句)是指由一對花括號括起來的若干條簡單的Java語句。塊確定了變量的作用域。一個塊可以嵌套在另一個塊中。下面就是在main方法塊中嵌套另一個語句塊的例子。

但是，不能在嵌套的兩個塊中聲明同名的變量。例如，下面的代碼就有錯誤，而無法通過編譯：

條件語句

在Java中，條件語句的格式為

if (condition) statement

這里的條件必須用括號括起來。

與絕大多數程序設計語言一樣，Java常常希望在某個條件為真時執行多條語句。在這種情況下，使用塊語句(block statement)，格式為

{statement1statement2. . .}

例如：

if (yourSales >= target){performance = "Satisfactory";bonus = 100;}

當yourSales大于或等于target時，將執行括號中的所有語句(請參看圖3-8)。在Java中，比較常見的條件語句格式如下所示(請參看圖3-9)：

if (condition) statement1 else statement2

例如：

其中else部分是可選的。else與最鄰近的if構成一組，因此，在語句

中else與第2個if配對。

重復地交替出現if…else if…是很常見的一種情況(請參看圖3-10)。例如：

循環

while循環當條件為true時執行一條語句(也可以是一個語句塊)。常用的格式為while (condition) statement如果開始循環條件就為false，則循環體一次也不執行請參看圖3-11)。

例3-3的程序將用來計算需要多長時間能夠存儲特定數量的退休金。假定每年存入相同數量的金額，而且利率是固定的。

在這個例子中，增加了一個計數器，并在循環體中更新當前的累積數量，直到總值超過目標值為止。

(千萬不要使用這個程序安排退休計劃。這里忽略了通貨膨脹和所期望的生活水準。)

while循環語句首先檢測循環條件。因此，循環體中的代碼有可能不被執行。如果希望循環體至少執行一次，就應該將檢測條件放置在最后。使用do/while循環語句可以實現這種操作方式。

它的語法格式為：

do statement while (condition);

這種循環語句先執行語句(通常是一個語句塊)，再檢測循環條件；然后重復語句，再檢測循環條件，以此類推。在例3-4的代碼中，首先計算退休賬戶中的余額，然后再詢問是否打算退休：

只要用戶回答 “N”，循環就重復執行(請參看圖3-12)。這是一個需要至少執行一次的循環的很好例子，因為用戶必須先看到余額才能知道是否滿足退休所用。

例3-3 Retirement.java

例3-4 Retirement2.java

確定循環

for循環語句是支持迭代的一種通用結構，使用每次迭代之后更新的計數器或類似的變量來控制迭代次數。如圖3-13所示，下面的程序將數字1～10輸出到屏幕上。

for (int i = 1; i <= 10; i++)

System.out.println(i);

for語句的第1部分通常用于對計數器初始化；第2部分給出每次循環前要檢測的循環條件；

第3部分指示如何更新計數器。

與C++一樣，盡管Java允許在for循環的各個部分放置任何表達式，但有一條不成文的規則：

for語句的3個部分應該對同一個計數器變量進行初始化、檢測和更新。若不遵守這一規則，編寫的循環常常晦澀難懂。

即使遵守了這條規則，也還有可能出現很多問題。例如，下面這個倒計數的循環：

for (int i = 10; i > 0; i--)

System.out.println("Counting down . . . " + i);

System.out.println("Blastoff!");

當在for語句的第1部分中聲明了一個變量之后，這個變量的作用域就為for循環的整個循環體。

尤其是，如果在for語句內部定義一個變量，那么這個變量值不能在循環體外使用。因此，如果希望在for循環體之外使用循環計數器的最終值，就要確保這個變量在循環語句的前面且在外部聲明

另一方面，可以在獨立的不同for循環中定義同名的變量：

for循環語句只不過是while循環的一種便捷形式。例如

可以重寫為：

例3-5給出了一個應用for循環的典型例子。

這個程序用來計算抽獎中獎的概率。例如，如果必須從1～50之間的數字中取6個數字來抽獎，那么會有 (50×49×48×47×46×45)/(1×2×3×4×5×6) 種可能的結果，所以中獎的幾率是1/15 890 700。祝你好運！

一般情況下，如果從n個數字中抽取k個數字，那么會有下列公式得到的結果。

下面的for循環語句計算了上面這個公式的值：

例3-5 LotteryOdds.java

多重選擇—switch語句

在處理多個選項時，使用if/else結構顯得有些笨拙。Java有一個與C/C++完全一樣的switch語句。

例如，如果建立一個如圖3-14所示的包含4個選項的菜單系統，就應該使用下列代碼：

switch語句將從匹配值的case標簽開始執行直到遇到break語句，或者執行到switch語句的結束處為止。如果沒有匹配的case標簽，而有default子句的話，就執行這個子句。

注意，case標簽必須是整數或枚舉常量，不能檢測字符串。

例如，下面這段代碼就存在錯誤。

中斷控制流程語句

盡管Java的設計者將goto作為保留字，但實際上并沒有打算在語言中使用它。通常，人們認為使用goto是一種拙劣的程序設計風格。當然，也有一些程序員認為反對goto的呼聲似乎有些過分(例如，Donald Knuth就曾編著過一篇名為“Structured Programming with goto statements”的著名文章)。該文章說：無限制地使用goto語句確實是導致錯誤的根源，但在有些情況下，偶爾使用goto跳出循環還是有益處的。Java設計者同意這種看法，甚至在Java語言中增加了一條帶標簽的break，以此來支持這種程序設計風格。

下面先來看看不帶標簽的break語句。與用于退出switch語句的break語句一樣，它也可以用于退出循環。例如：

當循環開始時years＞100，或者在循環中間balance≥goal時退出循環語句。當然，也可以在不使用break的情況下計算years的值，如下所示：

但是需要注意，在這個版本中，檢測了兩次balance < goal。為了避免重復檢測，有些程序員更加偏愛break語句。

與C++不同，Java還提供了一種帶標簽的break語句，用于跳出多重嵌套的循環語句。有些時候，在嵌套很深的循環語句中會發生一些不可預料的事情。此時可能更加希望完全跳出嵌套的所有循環語句。通過添加一些額外的條件判斷來實現對各層循環的檢測是很不方便的。

這里有一個例子說明了break語句的工作狀態。請注意，標簽必須放置在最外層的循環之前，并且必須緊跟一個冒號。

如果輸入有誤，則通過執行帶標簽的break跳轉到帶標簽的語句塊末尾。對于任何使用break的語句，都需要檢測循環是正常結束，還是通過break跳出。

因此，如果希望使用一條goto語句，并將一個標簽放置在想要跳過的語句塊前面，就可以使用break語句！當然，我們并不提倡使用這種方式。另外需要注意，只能跳出語句塊，而不能跳入語句塊。

最后，還有一個continue語句。與break語句一樣，它將中斷正常的控制流程。continue語句將控制轉移到最內層循環的首部。例如：

如果n＜0，則continue語句立刻跳到循環首部，越過了當前迭代的其余部分。如果將continue語句用于for循環中，就可以跳到for循環的“更新”部分。例如，以下這個循環：

如果n＜0，則continue語句跳到count++語句。還有一種帶標簽的continue語句，將跳到與標簽匹配的循環首部。

覺得文章不錯的話，可以轉發此文關注小編，之后持續更新干貨文章！！

總結

以上是生活随笔為你收集整理的java程序设计_80后程序员，带你深入理解Java基本的程序设计结构，不来你别后悔...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。