qileilove

JAVA程序員必讀：基礎篇（3）語言基礎

語言基礎

 我們先看看一個具體例子，給你們有個先入為主的感覺。以下是一個BasicsDemo程序，它的作用是從1加到10，并顯示結果：

public class BasicsDemo {

public static void main(String[] args) {

int sum = 0;

for (int current = 1; current <= 10; current++) {

sum += current;

}

System.out.println("Sum = " + sum);

}

}

這個程序的輸出為：

Sum = 55

　　從上面的例子中，我們可以看出即使是一個小的程序都要使用JAVA編程語言的許多傳統特性，其中包括變量、操作符和流程控制語句。以上的代碼可能看起來有點復雜，但是一旦你學習完本系列教程，你就會發覺它實際上很簡單。本節教程將教給你一些JAVA編程語言的基礎。
3.1 變量

　　你可以在程序中使用變量來容納數據。這一小節將數據類型、怎樣初始化變量以及怎樣在代碼塊中引用變量。 實際上，對象是存儲它的狀態在變量中的。它的具體定義為：變量是用標識符命名的數據項。

　　你必須清除地為你想在程序中使用地每一個變量提供一個名字和類型。這個變量的名字必須是一個合法的標識符：以字母開頭的一串Unicode字符。你可以使用變量名來引用變量包含的數據。這個變量的類型決定了什么類型的數值可以容納以及什么的操作可以對它進行操作。為了得到一個變量、類型和名字，你必須編寫變量聲明，如下：

type name

除了名字和類型你還要給變量一個作用域。變量的作用域是由變量聲明位置決定的。

以下MaxVariablesDemo程序，聲明了八個不同類型的變量，如下：

public class MaxVariablesDemo { public static void main(String args[]) { // 整型數 byte largestByte = Byte.MAX_VALUE; short largestShort = Short.MAX_VALUE; int largestInteger = Integer.MAX_VALUE; long largestLong = Long.MAX_VALUE; // 實型數 float largestFloat = Float.MAX_VALUE; double largestDouble = Double.MAX_VALUE; // 其它的數據類型：字符型和布爾型等等 char aChar = 'S'; boolean aBoolean = true; // 將它們顯示出來 System.out.println("The largest byte value is " + largestByte); System.out.println("The largest short value is " + largestShort); System.out.println("The largest integer value is " + largestInteger); System.out.println("The largest long value is " + largestLong); System.out.println("The largest float value is " + largestFloat); System.out.println("The largest double value is " + largestDouble); if (Character.isUpperCase(aChar)) { System.out.println("The character " + aChar + " is upper case."); } else { System.out.println("The character " + aChar + " is lower case."); } System.out.println("The value of aBoolean is " + aBoolean); } }

這個程序的輸出為：

The largest byte value is 127

The largest short value is 32767

The largest integer value is 2147483647

The largest long value is 9223372036854775807

The largest float value is 3.40282e+38

The largest double value is 1.79769e+308

The character S is upper case.

The value of aBoolean is true

　　下面的部分詳細介紹了變量的各個方法，包括數據類型、名字、作用域、初始化以及final變量。這個MaxVariablesDemo程序使用了你可能不熟悉并且不在本節提到的兩項：幾個常數MAX_VALUE以及一個if-else語句。每個MAX_VALUE常數是定義在由JAVA平臺提供的其中一個數字類中，它是最大的數值。
3.1.1 數據類型

　　每一個變量必須有一個數據類型。一個變量的數據類型決定了變量能容納的數值和操作符。比如 ，在MaxVariablesDemo程序中，聲明int largestInteger決定了largestInteger是一個整型數據類型（int）。整型只能容納整型數（可以是正數也可以是負數）。你可以完成算術操作，比如，整型變量的加法等等。

　　JAVA程序語言有兩類的數據類型：原始和引用。一個原始類型的變量為它的類型包含了適當大小和格式的單一數值：一個數字、字符或者一個布爾型數值。比如，一個整型數值是一個32位數據。

　　下面表格所有的JAVA支持的所有原始數據類型，還給出了它們的大小和格式以及簡短的描述。MaxVariablesDemo程序為每一個原始類型聲明了一個變量：

　　在其它語言中，原始類型數據的格式和大小可能依靠于程序運行的平臺。相比之下，Java程序語言可以指定原始數據類型的大小和格式。因此，你不必擔心系統從屬問題。

　　你可以在你的代碼中直接為原始變量設置數值。比如，如果你需要為一個整型變量設置為4，你可以編寫以下代碼：

int anInt = 4;

數字4就是一個整型數值。下面是各種原始數值舉例：

　　總得說來，沒有小數點的數就是整型。你可以通過在數字后面加一個'L' 或者'l'指定為一個長整型。一般使用'L'而不使用'l'，因為'l'很容易與數字'1'混起來。有小數點的數為雙精度類型。你可以在數字后面放置'f' 或者 'F'來指定為實數。而字符型數值可以是處在單引號中間的任何單一的Unicode字符；兩個布爾型數是true和false。

　　數組、類以及接口是引用的類型。引用類型變量的數值跟原始類型的數值比較起來，它是數值的一個引用或者是由變量代表的數值。

　　一個引用稱為一個指針或者在其它語言中稱為內存地址。JAVA編程語言象其它語言一樣不支持地址的詳細使用，你可以使用變量的名字來取代。
你可以在你的代碼中直接為原始變量設置數值。比如，如果你需要為一個整型變量設置為4，你可以編寫以下代碼：

int anInt = 4;

數字4就是一個整型數值。下面是各種原始數值舉例：

　　總得說來，沒有小數點的數就是整型。你可以通過在數字后面加一個'L' 或者'l'指定為一個長整型。一般使用'L'而不使用'l'，因為'l'很容易與數字'1'混起來。有小數點的數為雙精度類型。你可以在數字后面放置'f' 或者 'F'來指定為實數。而字符型數值可以是處在單引號中間的任何單一的Unicode字符；兩個布爾型數是true和false。

　　數組、類以及接口是引用的類型。引用類型變量的數值跟原始類型的數值比較起來，它是數值的一個引用或者是由變量代表的數值。

　　一個引用稱為一個指針或者在其它語言中稱為內存地址。JAVA編程語言象其它語言一樣不支持地址的詳細使用，你可以使用變量的名字來取代。
3.1.2 變量名

程序是用變量名來引用變量數值的。比如，當顯示largestByte變量的數值的時候，MaxVariablesDemo程序就使用名字largestByte。一個名字，比如largesByte包含了一個單一的標識符，被稱為簡單的名字（即變量名）。在JAVA編程語言中，對于變量名有下面的必須滿足：

1. 它必須是一個合法的標識符。一個標識符是以字母開頭的一串Unicode字符。

    

    

2. 它必須不是一個關鍵字、布爾型字符（true或者false）或者保留字NULL。

    

    

3. 它必須在作用域中是唯一的。在不同的作用域才允許存在相同名字的變量。在一些條件下，如果變量被定義在一個嵌套的代碼塊中，它可能和其它變量共享相同的名字。這點在以后的教程中會提到。

    

   這里有個約定：變量名是以小寫字母開頭，而類名是以一個大寫字母開頭的。如果變量名包含了多個單詞，而每個單詞要組合在一起，則在每個單詞的第一個字母大寫，比如IsVisible。而下劃線（_）可以處在變量的任何地方，但是一般地它只用在常數中分離單詞，因為常數名都是用大寫字母的，利用下劃線可以看得更清除。

3.1.3 作用域

變量的作用域是一個程序的區域，在上面變量可以通過它的名字來引用。其次，作用域也決定什么時候系統為變量創建和清除內存。作用域只應用成員變量并決定是否變量可以從所在類的外部使用。在程序中變量聲明的位置建立它的作用域并且將它放置到以下四類之一：

成員函數作用域

當地變量作用域

方法參數作用域

異常處理參數作用域

（圖14）

如圖14所示。成員變量示類或者對象的成員。它是在類中定義而不在任何方法或者構造函數中定義。成員函數的作用域是類的完全定義。但是，當成員是使用在成員初始化表達式中的時候，成員的定義需要在它使用之前出現。在后面的教程中我們要再深入學習成員變量，這里就不講了。

你可以在一個代碼塊中定義當地變量。總的說來，當地變量的作用域從它的聲明擴展到了它被定義的代碼塊結束。在MaxVariablesDemo中，定義在主方法中的所有變量都是當地變量。程序中的每一個變量的作用域從變量的定義擴展到了主方法的結束，它在程序代碼中是用右括號}來指示的。

參數是方法或者構造函數的正式參數，它們用于傳遞數值給方法和構造函數。參數的作用域是整個方法或者構造函數。

異常處理參數跟參數很相似，差別在是前者是傳遞參數給異常處理而后者是傳遞給方法或者構造函數。異常處理參數的作用域處在{和}之間的代碼，它緊跟著catch語句。利用異常來處理錯誤向你說明了怎樣編寫一個帶有參數的異常處理。以下是一個代碼例子：

if (...) {

int i = 17;

...

}

System.out.println("The value of i = " + i); // 錯誤

最后的行不匯編因為當地變量I已經出了作用域。i的作用域是處在{和}之間的代碼塊。變量I在右括號}之后就不存在了。改正的方法可以是講變量的聲明移到if語句塊的外面，或者是將println方法調用移動到if語句塊中。

3.1.4 變量初始化

當地變量和成員變量可以利用一個賦值語句來初始化。變量的數據類型必須與賦給它的數值的數據類型相匹配。下面程序中的當地變量聲明，其初始化如下：

// 整型

byte largestByte = Byte.MAX_VALUE;

short largestShort = Short.MAX_VALUE;

int largestInteger = Integer.MAX_VALUE;

long largestLong = Long.MAX_VALUE;

// 實數型

float largestFloat = Float.MAX_VALUE;

double largestDouble = Double.MAX_VALUE;

// 其它類型

char aChar = 'S';

boolean aBoolean = true;

參數和異常處理參數不能利用這種方法來初始化。它的參數的數值只能通過來設置。

3.1.5 final變量

你可以在任何作用域聲明一個變量。Final變量的數值不能在初始化之后進行改變。這樣的變量跟其它語言中的常量很相似。

為了聲明一個final變量，你可以在類型之前的變量聲明使用final關鍵字，比如：

final int aFinalVar = 0;

前面的語句聲明了一個final變量并一起對它進行了初始化。如果你在后面還想給aFinalVar賦其它的值的話，就會導致一個編譯錯誤。在必要的時候，你可以推遲對一個final本地變量進行初始化。你可以先定義，然后在之后再初始化，如下：

final int blankfinal;

. . .

blankfinal = 0;

已經聲明了但是還沒有初始化的final本地變量稱為空白final。同時，一旦final本地變量被初始化，它就不能再設置了。并且之后的任何對blankfinal賦值的操作都將導致一個編譯錯誤。

　當你聲明了一個變量，你就顯性地設置了變量的名字和數據類型。JAVA編程語言右兩類的數據類型：原始和引用。原始數據的變量包含一個數值。以下這張表顯示了所有的原始數據類型以及它們的大小和格式。

　　變量聲明的位置隱含地設置了變量的作用域，它決定了代碼的哪一部分可以通過變量名來調用這個變量。具體有以下四種類型的作用域：成員變量作用域、本地變量作用域、參數作用域以及異常處理參數作用域。

　　你可以使用賦值操作符（=）來在聲明的地方對變量進行初始化。

　　你也可以將變量聲明為final。Final變量的數值在初始化之后不能再被改變。

3.2 操作符

　　本節教程描述了怎執行各種操作，比如算術和賦值操作。

　　一個操作符利用一個、兩個或者三個運算對象來執行了一個函數。只需要一個運算對象的操作符稱為單元運算符。例如++是一個單元操作符，它是對運算對象自增1。需要兩個運算對象的操作符號稱為雙元操縱符。比如等于號（=）就是一個雙元操作符，它指定右邊的運算對象給左邊的運算對象。最后，三元操作符需要三個運算對象。JAVA編程語言有一個三元運算符？：，它是一個簡要的if-else語句。

　　單元操作符支持前綴或者后綴記號。前綴記號是指操作符出現在它的運算對象之前，例如：

operator op //前綴記號

后綴記號是指運算對象出現在操作符之前，例如：

op operator //后綴記號

所有的雙元操作符使用中綴記號，即操作符出現在兩個運算對象的中間：

op1 operator op2 //中綴記號

三元操作符也是使用中綴記號，例如：

op1 ? op2 : op3 //中綴記號

操作除了執行一個操作，還返回一個數值。返回數值和它的類型依靠于操作符號和運算對象的類型。比如，算術操作符它完成基本的算術操作（加、減）并且返回數值作為算術操作的結果。由算術操作符返回的數據類型依靠于它的運算對象的類型：如果你對兩個整型數相加，你就會得到一個整型數。

我們可以將操作符分成以下幾類：

算術運算符

關系和條件運算符

移位和邏輯運算符

賦值運算符

其它的運算符

下面我們逐個介紹。

3.2.1 算術操作符

　　JAVA編程語言為所有的浮點型和整型數支持多種算術運算符。這些運算符為+(加)、-（減）、*（乘）、/（除）以及%(模)。下面的表總結了雙元算術運算符。

　以下有一個例程，ArithmeticDemo，它定義了兩個整型數和兩個雙精度的浮點數并且使用五種算術運算符來完成不同的運算操作。這個程序同時使用了+符號來連接字符串。程序如下：

public class ArithmeticDemo { public static void main(String[] args) { //定義幾個數 int i = 37; int j = 42; double x = 27.475; double y = 7.22; System.out.println("變量數值..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" x = " + x); System.out.println(" y = " + y); //加 System.out.println("加..."); System.out.println(" i + j = " + (i + j)); System.out.println(" x + y = " + (x + y)); //減 System.out.println("減..."); System.out.println(" i - j = " + (i - j)); System.out.println(" x - y = " + (x - y)); //乘 System.out.println("乘..."); System.out.println(" i * j = " + (i * j)); System.out.println(" x * y = " + (x * y)); //除 System.out.println("除..."); System.out.println(" i / j = " + (i / j)); System.out.println(" x / y = " + (x / y)); //從除法中求得余數 System.out.println("計算余數..."); System.out.println(" i % j = " + (i % j)); System.out.println(" x % y = " + (x % y)); //混合類型 System.out.println("混合類型..."); System.out.println(" j + y = " + (j + y)); System.out.println(" i * x = " + (i * x)); } }

這個程序得輸出為：

變量數值...

i = 37

j = 42

x = 27.475

y = 7.22

加...

i + j = 79

x + y = 34.695

減...

i - j = -5

x - y = 20.255

乘...

i * j = 1554

x * y = 198.37

除...

i / j = 0

x / y = 3.8054

計算余數...

i % j = 37

x % y = 5.815

混合類型...

j + y = 49.22

i * x = 1016.58

這里注意，當一個整數和一個浮點數用為運算符來執行單一算術操作的時候，結果為浮點型。整型數是在操作之前轉換為一個浮點型數的。下面的表總結了根據運算對象的數據類型由算術操作符返回的數據類型。它們是在操作執行之前進行數據轉換的。

除了雙元的運算符+和-，還有以下單元運算符：

另外兩個簡練的算術操作符為++和--。++是完成自加1的作用；而—是完成自減的作用。不管是++還是—都可能出現在運算對象的前面（前綴）或者后面（后綴），但是它們的作用是不一樣的。前綴的格式為：++op或--op，它實現了在加/減之后才計算運算對象的數值；而后綴的格式為：op++或op--，它實現了在加/減之前就計算運算對象的數值。

下面的程序SortDemo中使用兩次++和一個--，如下：

public class SortDemo { public static void main(String[] args) { int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 }; for (int i = arrayOfInts.length; --i >= 0; ) { for (int j = 0; j < i; j++) { if (arrayOfInts[j] > arrayOfInts[j+1]) { int temp = arrayOfInts[j]; arrayOfInts[j] = arrayOfInts[j+1]; arrayOfInts[j+1] = temp; } } } for (int i = 0; i < arrayOfInts.length; i++) { System.out.print(arrayOfInts[i] + " "); } System.out.println(); } }

　　這個程序將10整型數值放置在一個數組arrayOfInts中。這個程序使用了arrayOfInts.length來獲得數組中的元素個數。單個的元素可以由arrayOfInts[index]來訪問，這里index是一個整型數，它指示數組中元素的位置。這里一定要注意index的下標是從0開始的。

這個程序的作用是輸出從小到大的10個整數，結果為：

3 8 12 32 87 127 589 622 1076 2000
　還是讓我們好好看看這個SortDemo程序是怎樣工作的。下面是控制外部循環的語句：

for (int i = arrayOfInts.length; --i >= 0; ) {

...

}

　　這個for語句是一個循環結構。其中--i >= 0給出了循環的條件，即--i大于等于0就繼續循環，一旦小于0就結束循環。使用前綴--意味著最后的一次循環迭代是發生在當i等于0的時候。如果我們改變改變一下使用后綴的，那么循環迭代的最后一次發生在當i等于-1的時候，這樣就會發生錯誤，因為數組的下標是從0開始的，-1是一個無效的數組下標。

　　程序中其它兩個循環使用了后綴的++。在兩個例子中，使用前綴或者后綴是沒有問題的。當其中一個運算符號返回的數值沒有用到，則約定使用后綴的。

下面的表格總結自增/自減運算符：

3.2.2 關系與條件運算符

關系運算符是比較兩個數值并決定它們的關系。比如!=在如果兩個運算對象不相等的情況下返回true。以下這個表格總結了關系運算符：

接下來介紹一個例子RelationalDemo。
下面是一個例子RelationalDemo，它定義了三個整型數并且使用關系運算符來比較它們，如下：

public class RelationalDemo { public static void main(String[] args) { //定義幾個數 int i = 37; int j = 42; int k = 42; System.out.println("變量數值..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" k = " + k); //大于 System.out.println("大于..."); System.out.println(" i > j = " + (i > j)); //false System.out.println(" j > i = " + (j > i)); //true System.out.println(" k > j = " + (k > j)); //false, they are equal //大于等于 System.out.println("大于等于..."); System.out.println(" i >= j = " + (i >= j)); //false System.out.println(" j >= i = " + (j >= i)); //true System.out.println(" k >= j = " + (k >= j)); //true //小于 System.out.println(小于..."); System.out.println(" i < j = " + (i < j)); //true System.out.println(" j < i = " + (j < i)); //false System.out.println(" k < j = " + (k < j)); //false //小于等于 System.out.println("小于等于..."); System.out.println(" i <= j = " + (i <= j)); //true System.out.println(" j <= i = " + (j <= i)); //false System.out.println(" k <= j = " + (k <= j)); //true //等于 System.out.println("等于..."); System.out.println(" i == j = " + (i == j)); //false System.out.println(" k == j = " + (k == j)); //true //不等于 System.out.println("不等于..."); System.out.println(" i != j = " + (i != j)); //true System.out.println(" k != j = " + (k != j)); //false } }

程序的輸出為：

變量數值...

i = 37

j = 42

k = 42

大于...

i > j = false

j > i = true

k > j = false

大于等于...

i >= j = false

j >= i = true

k >= j = true

小于...

i < j = true

j < i = false

k < j = false

小于等于...

i <= j = true

j <= i = false

k <= j = true

等于...

i == j = false

k == j = true

Not equal to...

i != j = true

k != j = false

關系運算符經常用在條件運算符中來構造更復雜的判斷表達式。JAVA變成語言支持六種條件運算符：五個雙元運算符和一個單元運算符，如下表所示；

　　&&運算符可以完成條件AND的操作。你可以使用兩個不同的關系運算符和&&來決定是否兩個關系都為true。下面的一行代碼使用了這個技術來決定是否數組的索引處在兩個邊界之間。它決定了是否索引都大于等于0并且小于等于NUM_ENTRIES(它是在之前被定義為常數)。

　　0 <= index && index < NUM_ENTRIES

　　這里注意在一些實例中，第二個運算對象可能不用運算，因為如果第一個運算對象是false，則結果就一個是false，因此不用在計算第二個運算對象了。你看看以下的代碼：

(numChars < LIMIT) && (...)

　　&&運算符只有在兩個運算對象都為true的時候，才返回true。因此，如果numChars大于等于LIMIT的時候，&&左邊的運算對象就為false，這時就不用在計算右邊的運算對象就返回了數值false。在這個例子中，編譯器將不會計算右邊的運算對象。如果右邊運算對象有副效應的的話（比如讀一個流、更新一個數值或者進行一個計算）這個有重要的含義。

　　當兩邊的運算對象都是boolean（布爾型），運算符號&跟&&執行相同運算。但是，&總是要計算兩邊的運算對象然后再在兩個運算對象同為true的時候才返回true。同樣地，當運算對象都為boolean（布爾型）的時候，|執行與操作符號||一樣的功能。這個|運算符總是要計算兩邊的運算對象然后在最少有一邊為true的時候才返回true。當它們的運算對象為數字的時候，& 和|是按位操作的。

3.2.3 移位和邏輯運算符

　　移位運算符通過對第一個運算對象左移或者右移位來對數據執行位操作。下面的這個表總結了JAVA編程語言中有效的移位運算符。

　　每一個運算符移動左邊的運算對象的位數都是由右邊的運算符給出的。這個移位的方向取決于運算符本身。比如，下面的語句是實現將整數13右移1位的目的：

13 >> 1;

　　13的二進制為1101.右移一位的結果為110，即為十進制的6.左邊的位用零來填充。下面的表給出了JAVA編程語言提供的四種運算符來對它們的運算對象執行按位操作：

　　當它的運算對象為數字的時候，&運算符為每一個運算對象的每位執行按位AND功能。AND在運算對象的相應位為1的時候結果才為1，其余情況結果都為0，如下表所示：

　　假如你要對數13和12作AND操作，比如13&12。運算的結果為12，因為12的二進制為1100，遙13的二進制為1101，具體運算過程如下所示：

1101 //13

& 1100 //12

------

1100 //12

　　如果兩個運算對象都為1，AND的結果就為1，或者結果就為0。因此，當你對兩個運算對象執行AND操作的時候，你可以看到左邊的兩位結果位1，而右邊兩位的結果為0。當兩個操作對象都位數字的時候，|操作符執行或操作，而^執行異或操作。或操作是說只要有一個運算對象為1結果就為1。下面的表格給出了或操作的結果：

　　異或是指當運算對象不同時結果才為1，或者結果為0。下表給出了異或運算符的計算結果：

　　最后，補運算符號是將運算對象的每一位倒置，即如果原來的位位1結果就為0，如果原來的位為0則結果為1。

　通常，按位操作對于管理boolean標識是很有用的。假如，程序中有幾個boolean標識來指示各種組件的狀態：它是否可見、它是否可以拖拉等等。與其定義一個單獨的boolean變量，不如你定義單一的變量flags，在flags的每一位都代表了這些標識的當前狀態。然后你可以使用位操作來設置或者得到每一個標識。首先，為程序設置常數來指示各種標識。定義一個變量flags，它的位要根據每個flag的當前狀態來設置。下面的代碼將flags初始化為0，意味著所有的標識的初始狀態都位0。 如下：

static final int VISIBLE = 1;

static final int DRAGGABLE = 2;

static final int SELECTABLE = 4;

static final int EDITABLE = 8;

int flags = 0;

　　為了當有事物變得可見要設置"visible"標識，你可以使用以下的語句：

flags = flags | VISIBLE;

　　為了測試可見性，你可以編寫如下的語句：

if ((flags & VISIBLE) == VISIBLE) {

...

}

下一頁是完整的程序BitwiseDemo。

下面是完整的程序BitwiseDemo：

public class BitwiseDemo { static final int VISIBLE = 1; static final int DRAGGABLE = 2; static final int SELECTABLE = 4; static final int EDITABLE = 8; public static void main(String[] args) { int flags = 0; flags = flags | VISIBLE; flags = flags | DRAGGABLE; if ((flags & VISIBLE) == VISIBLE) { if ((flags & DRAGGABLE) == DRAGGABLE) { System.out.println("Flags are Visible and Draggable."); } } flags = flags | EDITABLE; if ((flags & EDITABLE) == EDITABLE) { System.out.println("Flags are now also Editable."); } } }

這個程序的輸出為：

Flags are Visible and Draggable.

Flags are now also Editable.

3.2.4 賦值運算符

你可以基本的賦值運算符=來為其它的賦值。MaxVariablesDemo程序使用=來初始化所有的本地變量：

// 整型

byte largestByte = Byte.MAX_VALUE;

short largestShort = Short.MAX_VALUE;

int largestInteger = Integer.MAX_VALUE;

long largestLong = Long.MAX_VALUE;

//實數

float largestFloat = Float.MAX_VALUE;

double largestDouble = Double.MAX_VALUE;

//其它類型

char aChar = 'S';

boolean aBoolean = true;

JAVA編程語言同樣提供了幾個簡潔的賦值運算符以進行算術、移位或者按位操作或者賦值操作。假如你想為一個變量增加一個數并將結果指定給該變量，你可以這樣做：

i = i + 2;

當然你還可以這樣來進行簡化，主要是用了+=運算符：

i += 2;

上面的兩行是等價的。

下面的表列出了所有的賦值運算符和它們的等價形式：

3.2.5 其它的運算符

下面的表格給出了JAVA編程語言支持的其它運算符。

下面的表格給出了JAVA編程語言支持的其它運算符。

下面逐個介紹：

(1)簡化的if-else語句：

這個?:運算符是一個條件運算符號，它是一個簡化的if-else語句：

op1 ? op2 : op3

這個?:運算符號在op1為true的時候返回op2，或者返回op3。

(2) [ ] 運算符

你可以使用方括號來聲明數組、創建數組并且訪問數組中一個特殊的元素。以下是數組聲明的一個例子：

float[] arrayOfFloats = new float[10];

前面的代碼聲明了一個數組來容納10個浮點型的數字。以下給出訪問第7個元素的方法：

arrayOfFloats[6];

這里注意第7個元素的下標是6，因為第一個元素的下標為0.

（3）.運算符

點運算符是訪問對象實例或者類的類成員函數。

（4）（）運算符

當聲明或者調用一個方法的時候，你可以在(和)之間列出方法的參數。你可以利用()來指定一個空的參數列表。

• (type)運算符

這個運算符可以將數值轉換為一個指定的類型。

• new運算符

你可以使用new運算符號來創建一個新對象或者一個新數組。以下是一個從java.lang包中的Interger類創建新的整型對象：

Integer anInteger = new Integer(10);

（6）instanceof運算符

instanceof操作符測試第一個運算對象是否是第二個運算對象的實例，比如：

op1 instanceof op2

這里，op1必須是對象的名字而且op2必須是類的名字。如果對象直接或者間接地來自類，那么對象就被認為是類的一個實例。

3.3 表達式、語句和塊

　　這一節教程討論怎樣將運算符和變量集中到表達式中去。表達式是代碼的構建塊。你同樣還可以學到怎樣構造語句和語句塊。

變量和運算符是程序的基本構造塊。你可以集中變量和運算符來組成表達式（表達式是執行計算并返回數值的代碼段）。通過使用大括號{和}你可以創建代碼塊。

3.3.1表達式

　　表達式執行程序的工作。跟其它事情一樣，表達式用于計算和為變量賦值并且幫助控制程序的執行流程。表達式任務有兩重：利用表達式的元素來執行計算；返回計算結果的數值。

　　就象前面的章節討論的，運算符要返回一個數值，因此運算符的使用就是一個表達式。如下的程序：

…

char aChar = 'S';

boolean aBoolean = true;

// 顯示

System.out.println("The largest byte value is " + largestByte);

...

if (Character.isUpperCase(aChar)) {

...

}

每一個條語句執行一個操作并且返回一個數值。如下表所示：

　　表達式返回數值的數據類型依靠于使用在表達式中的元素。這個表達式aChar = 'S'返回一個字符型，因為賦值操作符返回相同數據類型（操作符和aChar以及'S'都是字符型）的數值。從其它表達式可以看出，表達式可以返回一個boolean數值、字符串等等。

　　只要表達式子需要的數據類型匹配其它的數據類型，JAVA編程語言允許你將多個小的表達式構造復合的表達式。下面是一個復合的表達式例子：

x * y * z

　　在這個消息的例子中，各個運算對象的先后順序不是很重要因為乘法的結果跟順序無關。但是這對于其它表達式有時并不適合。例如，下面的表達式就跟順序有關了，它關系到是哪個先乘還是先加的問題：

x + y / 100

　　你可以利用括號(和)來正確指定表達式。比如為了避免上面表達式子的含糊性，你可以這樣編寫：

(x + y)/ 100 //推薦使用這種方法，以養成良好的編程習慣

　　如果你沒有在復合的表達式中指定各個運算的順序，那么運算的順序將取決于表達式中的運算符的優先順序，即優先順序高的先進行計算。比如除法運算符的優先順序高于加法運算符，所以以下的兩條語句是等價的。

x + y / 100

x + (y / 100)

　　雖然它們是等價的，還是推薦是推薦使用第二種。在編寫復合表達式的時候，推薦你利用圓括號(和)來清楚指定計算的順序，這便于程序的閱讀以及維護。

　下面的表格給出了各種運算符的優先順序。前面的運算符優先順序高于后面的運算符，同一行的運算符，其優先順序相同：

　　當相同優先級的運算符出現在相同的表達式中，所有的雙元運算符的運算順序是從左到右，而賦值運算符是從右到左計算的

3.3.2 語句

　　語句粗略地等價于自然語言的句子。一個語句組成了一個執行的完整單元。以下表達式的類型可以通過用逗號（;）終止表達式來組成一條語句：

1. 賦值語句

    

    

2. 任何使用++或者--的語句

    

    

3. 方法調用

    

    

4. 對象創建表達式

    

這些語句的種類稱為表達式語句。以下是表達式語句：

aValue = 8933.234; //賦值語句

aValue++; //增量語句

System.out.println(aValue); //方法調用語句

Integer integerObject = new Integer(4); //對象創建語句

除了上面的這些表達式語句，還有另外兩種語句：

（1）定義變量的聲明語句。以下給出聲明變量的語句：

double aValue = 8933.234; // 聲明語句

（2）控制流程語句，它控制了語句執行的先后順序。For循環語句和if語句都是控制流程語句的例子。

3.3.3 塊

　　塊是一組處在{和}之間的零條或者多條語句，它可以使用在程序的任何地方。下面的例子給出了兩個塊，每一個塊中包含了一條語句：

if (Character.isUpperCase(aChar)) {

System.out.println("The character " + aChar + " is upper case.");

} else {

System.out.println("The character " + aChar + " is lower case.");

}

3.4 控制流程語句

　　程序使用控制流程語句來有條件地執行語句、循環語句或者跳轉到程序中的其它部分執行語句。這節教程介紹怎樣利用比如if-else和while來控制你的程序流程。

　　當你編寫程序的時候，你在文件中鍵如語句。如果你沒有使用控制流程語句，編譯器將以從左到右、從上到下的順序執行這些語句。你可以在你的程序中使用控制流程語句來有條件地執行語句、來重復執行語句塊地代碼、改變程序執行的順序等等。比如，在下面的代碼段中，if語句就有條件執行了括號中的System.out.println，這里的條件是Character.isUpperCase(aChar)的返回值：

char c;

...

if (Character.isUpperCase(aChar)) {

System.out.println("The character " + aChar + " is upper case.");

}

JAVA編程語言提供了幾個控制流程語句，在下表給出了：

控制流程語句的基本格式為：

控制流程語句描述

{

語句（參數）

}

如果塊中只有一條語句，大括號{和}并不是必要的。但是這里推薦使用{和}，因為代碼會更容易閱讀，避免在修改代碼的時候發生錯誤。

控制流程語句有：

1. while和do-while語句

    

    

2. for語句

    

    

3. if-else語句

    

    

4. switch語句

    

    

5. 異常處理語句

    

    

6. 分支語句

    

這里注意，雖然goto是一個保留字，它在C語言中也是一個控制流程語句，但是當前JAVA編程語言還不支持這個goto語句。

好吧，我們開始對各個控制流程語句逐個介紹。
3.4.1 while和do-while語句

　　你可以使用while語句當條件保持為true的時候，持續執行語句塊。While語句的通常語法為：

while (expression) {

statement

}

　　首先，while語句執行表達式，它將返回一個boolean數（true或者false）。如果表達式返回true，while語句執行相應的語句。While語句繼續測試表達式并執行塊代碼直到表達式返回false。

　　下面給出一個例程WhileDemo，它使用while語句來瀏覽字符串的各個字符并復制字符串直到程序找到字符g為止：

public class WhileDemo {

public static void main(String[] args) {

String copyFromMe = "Copy this string until you " +

"encounter the letter 'g'.";

StringBuffer copyToMe = new StringBuffer();

int i = 0;

char c = copyFromMe.charAt(i);

while (c != 'g') {

copyToMe.append(c);

c = copyFromMe.charAt(++i);

}

System.out.println(copyToMe);

}

}

　　最后一行打印出來的數值為：Copy this strin.
JAVA編程語言提供了另外一個語句，它跟while語句和相似，即do-while語句。Do-while的語法為：

do {

statement(s)

} while (expression);

　　不象while語句，do-while語句是先執行循環中的語句后再計算表達式的，所以do-while語句就至少執行一次語句。

　　下面是對上面的程序利用do-while來修改而得的：

public class DoWhileDemo {

public static void main(String[] args) {

String copyFromMe = "Copy this string until you " +

"encounter the letter 'g'.";

StringBuffer copyToMe = new StringBuffer();

int i = 0;

char c = copyFromMe.charAt(i);

do {

copyToMe.append(c);

c = copyFromMe.charAt(++i);

} while (c != 'g');

System.out.println(copyToMe);

}

}

　　最后一行打印出來的數值為：Copy this strin

3.4.2 for語句

for語句提供了一個簡便的方法來進行循環。For語句的語法如下：

for (初始條件;終止條件;增量) {

語句

}

　　初始條件是初始化循環的表達式，它在循環開始的時候就被執行一次。而終止條件決定什么時候終止循環。這個表達式在每次循環的過程都被計算。當表達式計算結果為false的時候，這個循環結束。最后,增量是循環一次增加多少（即步長）的表達式。所有的這些都是可選的。實際上，為了實現無限制的循環，這三個表達式都可以省略。

for ( ; ; ) { // 無限制的循環

...

}

　　下面是一個例程ForDemo，它使用了一個for語句來打印一個數組的所有元素：

public class ForDemo {

public static void main(String[] args) {

int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,

2000, 8, 622, 127 };

for (int i = 0; i < arrayOfInts.length; i++) {

System.out.print(arrayOfInts[i] + " ");

}

System.out.println();

}

}

這個程序的輸出為： 32 87 3 589 12 1076 2000 8 622 127.

　　這里注意你可以在for循環的初始化語句中聲明一個本地變量。這個變量的作用域只是在for語句的塊中，它可以用在終止條件語句和增量表達式中。如果控制for循環的變量沒有用在循環的外部，最好的方法是在初始化表達式中聲明這個變量。例如i、j、k等經常用來在for控制語句中，在for循環的初始化表達式中聲明它們來限制它們的生命周期以減少錯誤

3.4.3 if-else語句

　　if語句可以使程序根據一些條件有選擇地執行語句。舉個例子，假如你的程序根據boolean變量DEBUG的值來打印了調試信息。如果DEBUG是true，你的程序就打印出調試信息，比如變量x的數值；或者就不打印。具體的程序如下：

if (DEBUG) {

System.out.println("DEBUG: x = " + x);

}

上面是一個簡單的if語句的例子。總得說來，if語句的語法格式為：

if (表達式) {

語句（參數）

}

　　如果你想在if判斷表達式為false的時候執行不同的語句，你可以使用else語句。舉個另外的例子吧，假如你的程序需要執行不同的工作，主要是根據用戶是點擊OK鍵還是擊警告窗口中的其它按鈕。你可以使用if和else語句來實現這個目的：

. . .

// response is either OK or CANCEL depending

// on the button that the user pressed

. . .

if (response == OK) {

// 在這里添加執行OK動作的代碼

} else {

// 在這里添加執行Cancel動作的代碼
如果if部分為false，則執行else塊。另外一種else語句的格式是else if，它根據執行另外的表達式執行語句。一個if語句可以跟著任意個else if語句，但只能有一個else語句。下面是一個例程IfElseDemo，它根據測試分數的數值來指定一個等級：90％或者更高為A，80％或者更高為B等等。

public class IfElseDemo {

public static void main(String[] args) {

int testscore = 76;

char grade;

if (testscore >= 90) {

grade = 'A';

} else if (testscore >= 80) {

grade = 'B';

} else if (testscore >= 70) {

grade = 'C';

} else if (testscore >= 60) {

grade = 'D';

} else {

grade = 'F';

}

System.out.println("Grade = " + grade);

}

}

程序的輸出為：

Grade = C
這時你可以注意到testscore的數值可以滿足組合if條件76 >= 70 and 76 >= 60，但是當系統處理組合if語句的時候，一旦條件滿足，適當的語句就將被執行(grade = 'C';)，并且不需要計算剩余的條件控制就跳出if語句。JAVA編程語言支持運算符?:，它是一個簡化的if語句。 下面再看看上面教程中的MaxVariablesDemo程序：

if (Character.isUpperCase(aChar)) {

System.out.println("The character " + aChar + " is upper case.");

} else {

System.out.println("The character " + aChar + " is lower case.");

}

下面你可以利用?:運算符來重寫這段代碼：

System.out.println("The character " + aChar + " is " +

(Character.isUpperCase(aChar) ? "upper" : "lower") +

"case.");

　　如果這個isUpperCase方法返回true，這個?:運算符返回字符串"upper" 。或則，它就返回字符串"lower"
3.4.4 switch語句

　　使用switch語句可以根據一個整型表達式有條件地執行語句。下面的例程SwitchDemo，聲明了一個整型變量month，它的數值代表了月份。這個程序顯示了月份的名字，主要是根據month的數值并且使用了switch語句。

public class SwitchDemo {

public static void main(String[] args) {

int month = 8;

switch (month) {

case 1: System.out.println("January"); break;

case 2: System.out.println("February"); break;

case 3: System.out.println("March"); break;

case 4: System.out.println("April"); break;

case 5: System.out.println("May"); break;

case 6: System.out.println("June"); break;

case 7: System.out.println("July"); break;

case 8: System.out.println("August"); break;

case 9: System.out.println("September"); break;

case 10: System.out.println("October"); break;

case 11: System.out.println("November"); break;

case 12: System.out.println("December"); break;

}

}

}

　　這個switch語句計算它的表達式，在這個例子中是計算month的數值，然后計算適當的case 語句。這樣，程序的輸出為：August。

當然，你可以使用if語句來實現它：

int month = 8;

if (month == 1) {

System.out.println("January");

} else if (month == 2) {

System.out.println("February");

}

. . .

　　決定使用if語句還是switch語句的關鍵主要是根據可讀型以及其它因素。if語句可以在更大范圍或者條件來決定，而switch只有根據單個整型變量來做決定。同時，提供給case語句的數值必須是單一的。另外一點是，switch語句在每個case之后有一個break語句。每個break語句終止了swtich語句，并且控制流程繼續switch塊之后的第一個語句。break語句是必須的，因為沒有它，case語句就會失效，也就是說，沒有break語句，控制流程按順序執行case語句。

　　下面的程序SwichDemo2將介紹為什么它是有效的；

public class SwitchDemo2 { public static void main(String[] args) { int month = 2; int year = 2000; int numDays = 0; switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: numDays = 31; break; case 4: case 6: case 9: case 11: numDays = 30; break; case 2: if ( ((year % 4 == 0) && !(year % 100 == 0)) || (year % 400 == 0) ) numDays = 29; else numDays = 28; break; } System.out.println("Number of Days = " + numDays); } }

這個程序的輸出為：

Number of Days = 29

　　最后的break語句是不需要的，因為流程將跳出switch語句了。但是，我們推薦使用為最后一個case語句使用一個break以防你需要還增加更多的case語句。這就使得更容易修改代碼以及減少錯誤。

　一般地，你可以使用break來在分支語句中終止循環。最后你可以在switch最后使用缺省地語句來處理所有的上面沒有處理的情況。

int month = 8;

. . .

switch (month) {

case 1: System.out.println("January"); break;

case 2: System.out.println("February"); break;

case 3: System.out.println("March"); break;

case 4: System.out.println("April"); break;

case 5: System.out.println("May"); break;

case 6: System.out.println("June"); break;

case 7: System.out.println("July"); break;

case 8: System.out.println("August"); break;

case 9: System.out.println("September"); break;

case 10: System.out.println("October"); break;

case 11: System.out.println("November"); break;

case 12: System.out.println("December"); break;

default: System.out.println("Hey, that's not a valid month!"); break;

}

3.4.5 異常處理語句

JAVA編程語言提供一個異常機制用來幫助程序報告和處理錯誤。當一個錯誤發生的時候，程序就產生一個異常。即正常的程序路程被中斷并且系統緩建想找到一個異常處理：一個能處理特殊類型錯誤的代碼塊。這個異常福利可以視圖恢復錯誤或者如果它決定了錯誤是不可修復的，它提供一個較好退出程序的方法。

有三條語句可以處理異常：

1. try語句，它可以在異常產生的地方識別語句塊。

    

    

2. catch語句，它必須和try語句一起用，它可是識別可以處理特定異常錯誤的語句塊。這個語句是在如果有一個特定的異常發生在try塊中就被執行。

    

（3）finally語句，它必須跟try語句一起用，它可以識別語句塊，這些語句塊是在不管在try塊中是否有錯誤發生被執行的。

下面是這三個語句的語法格式：

try {

語句（參數）

} catch (異常錯誤類型 名字) {

語句（參數）

} finally {

語句（參數）

}

上面簡述了由JAVA編程語言提供的用來報告和處理錯誤的語句。但是，另外的因素和原因，比如運行和檢查異常之間的差異以及異常類的分級結構（代表異常的不同種類）在使用異常機制的時候起著重要的作用。

3.4.6 分支語句

JAVA編程語言支持下面的三種分支結構：

break語句

continue語句

return語句

（1）break語句

　　break語句有兩種形式：未標志的和標志的。你在前面就已經看過了未標志的break語句。一個未標志的break語句終止swtich語句，控制流程馬上轉到switch語句下方的語句。下面的例程BreakDemo，它包含了一個for循環查找數組中特定的數值：

public class BreakDemo {

public static void main(String[] args) {

int[] arrayOfInts = { 32, 87, 3, 589, 12, 1076,

2000, 8, 622, 127 };

int searchfor = 12;

int i = 0;

boolean foundIt = false;

for ( ; i < arrayOfInts.length; i++) {

if (arrayOfInts[i] == searchfor) {

foundIt = true;

break;

}

}

if (foundIt) {

System.out.println("Found " + searchfor + " at index " + i);

} else {

System.out.println(searchfor + "not in the array");

}

}

}

　　當數值被找到的時候，這個break語句終止了for循環。控制流程就轉到for語句的下面的語句繼續執行。這個程序的輸出為： Found 12 at index 4
　未標志形式的break語句被用來終止內部的switch、for、while或者do-while。而標志形式的break語句終止一個外部的語句，它是通過在break語句中使用一個標志來實現的。下面的例程BreakWithLabelDemo跟前面的例子有點相似，只不過它是在一個兩維數組中搜索一個數值。利用兩個嵌套的for循環遍歷了整個數組。當數值被找到了，標志形式的break語句就終止標志的search語句，這個search語句是在for循環外部的：

public class BreakWithLabelDemo {

public static void main(String[] args) {

int[][] arrayOfInts = { { 32, 87, 3, 589 },

{ 12, 1076, 2000, 8 },

{ 622, 127, 77, 955 }

};

int searchfor = 12;

int i = 0;

int j = 0;

boolean foundIt = false;

search:

for ( ; i < arrayOfInts.length; i++) {

for (j = 0; j < arrayOfInts[i].length; j++) {

if (arrayOfInts[i][j] == searchfor) {

foundIt = true;

break search;

}

}

}

if (foundIt) {

System.out.println("Found " + searchfor + " at " + i + ", " + j);

} else {

System.out.println(searchfor + "not in the array");

}

}

}

這個程序的輸出為：

Found 12 at 1, 0

　　這個語法看起來可能有點費解。break語句終止了標志語句，它不能將控制流程轉到這個標志處。控制流程迅速將標志（終止的）后面的語句。

（2）continue語句

　　你可以使用continue語句來跳過當前的for、while或者do-while循環。未標志形式跳到內部循環體的末尾處并且計算控制循環的boolean表達式，跳過循環的其它部分。下面的例程ContinueDemo遍歷字符串中的所有字母。如果當前字母不是一個p，contiue語句就忽略循環的其它部分并且處理下一個字符。如果它是一個p字母，程序就對計數器增1，再將p轉換維大寫字母：

public class ContinueDemo {

public static void main(String[] args) {

StringBuffer searchMe = new StringBuffer(

"peter piper picked a peck of pickled peppers");

int max = searchMe.length();

int numPs = 0;

for (int i = 0; i < max; i++) {

//interested only in p's

if (searchMe.charAt(i) != 'p')

continue;

//process p's

numPs++;

searchMe.setCharAt(i, 'P');

}

System.out.println("Found " + numPs + " p's in the string.");

System.out.println(searchMe);

}

}

這個程序的輸出為：

Found 9 p's in the string.

Peter PiPer Picked a Peck of Pickled PePPers