qileilove

JAVA程序員必讀：基礎(chǔ)篇（3）語言基礎(chǔ)

語言基礎(chǔ)

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

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);

}

}

這個(gè)程序的輸出為：

Sum = 55

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

　　你可以在程序中使用變量來容納數(shù)據(jù)。這一小節(jié)將數(shù)據(jù)類型、怎樣初始化變量以及怎樣在代碼塊中引用變量。 實(shí)際上，對象是存儲它的狀態(tài)在變量中的。它的具體定義為：變量是用標(biāo)識符命名的數(shù)據(jù)項(xiàng)。

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

type name

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

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

public class MaxVariablesDemo { public static void main(String args[]) { // 整型數(shù) byte largestByte = Byte.MAX_VALUE; short largestShort = Short.MAX_VALUE; int largestInteger = Integer.MAX_VALUE; long largestLong = Long.MAX_VALUE; // 實(shí)型數(shù) float largestFloat = Float.MAX_VALUE; double largestDouble = Double.MAX_VALUE; // 其它的數(shù)據(jù)類型：字符型和布爾型等等 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); } }

這個(gè)程序的輸出為：

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

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

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

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

　　下面表格所有的JAVA支持的所有原始數(shù)據(jù)類型，還給出了它們的大小和格式以及簡短的描述。MaxVariablesDemo程序?yàn)槊恳粋€(gè)原始類型聲明了一個(gè)變量：

　　在其它語言中，原始類型數(shù)據(jù)的格式和大小可能依靠于程序運(yùn)行的平臺。相比之下，Java程序語言可以指定原始數(shù)據(jù)類型的大小和格式。因此，你不必?fù)?dān)心系統(tǒng)從屬問題。

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

int anInt = 4;

數(shù)字4就是一個(gè)整型數(shù)值。下面是各種原始數(shù)值舉例：

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

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

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

int anInt = 4;

數(shù)字4就是一個(gè)整型數(shù)值。下面是各種原始數(shù)值舉例：

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

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

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

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

1. 它必須是一個(gè)合法的標(biāo)識符。一個(gè)標(biāo)識符是以字母開頭的一串Unicode字符。

    

    

2. 它必須不是一個(gè)關(guān)鍵字、布爾型字符（true或者false）或者保留字NULL。

    

    

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

    

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

3.1.3 作用域

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

成員函數(shù)作用域

當(dāng)?shù)刈兞孔饔糜?/p>

方法參數(shù)作用域

異常處理參數(shù)作用域

（圖14）

如圖14所示。成員變量示類或者對象的成員。它是在類中定義而不在任何方法或者構(gòu)造函數(shù)中定義。成員函數(shù)的作用域是類的完全定義。但是，當(dāng)成員是使用在成員初始化表達(dá)式中的時(shí)候，成員的定義需要在它使用之前出現(xiàn)。在后面的教程中我們要再深入學(xué)習(xí)成員變量，這里就不講了。

你可以在一個(gè)代碼塊中定義當(dāng)?shù)刈兞??？偟恼f來，當(dāng)?shù)刈兞康淖饔糜驈乃穆暶鲾U(kuò)展到了它被定義的代碼塊結(jié)束。在MaxVariablesDemo中，定義在主方法中的所有變量都是當(dāng)?shù)刈兞俊３绦蛑械拿恳粋€(gè)變量的作用域從變量的定義擴(kuò)展到了主方法的結(jié)束，它在程序代碼中是用右括號}來指示的。

參數(shù)是方法或者構(gòu)造函數(shù)的正式參數(shù)，它們用于傳遞數(shù)值給方法和構(gòu)造函數(shù)。參數(shù)的作用域是整個(gè)方法或者構(gòu)造函數(shù)。

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

if (...) {

int i = 17;

...

}

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

最后的行不匯編因?yàn)楫?dāng)?shù)刈兞縄已經(jīng)出了作用域。i的作用域是處在{和}之間的代碼塊。變量I在右括號}之后就不存在了。改正的方法可以是講變量的聲明移到if語句塊的外面，或者是將println方法調(diào)用移動到if語句塊中。

3.1.4 變量初始化

當(dāng)?shù)刈兞亢统蓡T變量可以利用一個(gè)賦值語句來初始化。變量的數(shù)據(jù)類型必須與賦給它的數(shù)值的數(shù)據(jù)類型相匹配。下面程序中的當(dāng)?shù)刈兞柯暶鳎涑跏蓟缦拢?

// 整型

byte largestByte = Byte.MAX_VALUE;

short largestShort = Short.MAX_VALUE;

int largestInteger = Integer.MAX_VALUE;

long largestLong = Long.MAX_VALUE;

// 實(shí)數(shù)型

float largestFloat = Float.MAX_VALUE;

double largestDouble = Double.MAX_VALUE;

// 其它類型

char aChar = 'S';

boolean aBoolean = true;

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

3.1.5 final變量

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

為了聲明一個(gè)final變量，你可以在類型之前的變量聲明使用final關(guān)鍵字，比如：

final int aFinalVar = 0;

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

final int blankfinal;

. . .

blankfinal = 0;

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

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

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

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

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

3.2 操作符

　　本節(jié)教程描述了怎執(zhí)行各種操作，比如算術(shù)和賦值操作。

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

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

operator op //前綴記號

后綴記號是指運(yùn)算對象出現(xiàn)在操作符之前，例如：

op operator //后綴記號

所有的雙元操作符使用中綴記號，即操作符出現(xiàn)在兩個(gè)運(yùn)算對象的中間：

op1 operator op2 //中綴記號

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

op1 ? op2 : op3 //中綴記號

操作除了執(zhí)行一個(gè)操作，還返回一個(gè)數(shù)值。返回?cái)?shù)值和它的類型依靠于操作符號和運(yùn)算對象的類型。比如，算術(shù)操作符它完成基本的算術(shù)操作（加、減）并且返回?cái)?shù)值作為算術(shù)操作的結(jié)果。由算術(shù)操作符返回的數(shù)據(jù)類型依靠于它的運(yùn)算對象的類型：如果你對兩個(gè)整型數(shù)相加，你就會得到一個(gè)整型數(shù)。

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

算術(shù)運(yùn)算符

關(guān)系和條件運(yùn)算符

移位和邏輯運(yùn)算符

賦值運(yùn)算符

其它的運(yùn)算符

下面我們逐個(gè)介紹。

3.2.1 算術(shù)操作符

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

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

public class ArithmeticDemo { public static void main(String[] args) { //定義幾個(gè)數(shù) int i = 37; int j = 42; double x = 27.475; double y = 7.22; System.out.println("變量數(shù)值..."); 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)); //從除法中求得余數(shù) System.out.println("計(jì)算余數(shù)..."); 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)); } }

這個(gè)程序得輸出為：

變量數(shù)值...

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

計(jì)算余數(shù)...

i % j = 37

x % y = 5.815

混合類型...

j + y = 49.22

i * x = 1016.58

這里注意，當(dāng)一個(gè)整數(shù)和一個(gè)浮點(diǎn)數(shù)用為運(yùn)算符來執(zhí)行單一算術(shù)操作的時(shí)候，結(jié)果為浮點(diǎn)型。整型數(shù)是在操作之前轉(zhuǎn)換為一個(gè)浮點(diǎn)型數(shù)的。下面的表總結(jié)了根據(jù)運(yùn)算對象的數(shù)據(jù)類型由算術(shù)操作符返回的數(shù)據(jù)類型。它們是在操作執(zhí)行之前進(jìn)行數(shù)據(jù)轉(zhuǎn)換的。

除了雙元的運(yùn)算符+和-，還有以下單元運(yùn)算符：

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

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

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(); } }

　　這個(gè)程序?qū)?0整型數(shù)值放置在一個(gè)數(shù)組arrayOfInts中。這個(gè)程序使用了arrayOfInts.length來獲得數(shù)組中的元素個(gè)數(shù)。單個(gè)的元素可以由arrayOfInts[index]來訪問，這里index是一個(gè)整型數(shù)，它指示數(shù)組中元素的位置。這里一定要注意index的下標(biāo)是從0開始的。

這個(gè)程序的作用是輸出從小到大的10個(gè)整數(shù)，結(jié)果為：

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

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

...

}

　　這個(gè)for語句是一個(gè)循環(huán)結(jié)構(gòu)。其中--i >= 0給出了循環(huán)的條件，即--i大于等于0就繼續(xù)循環(huán)，一旦小于0就結(jié)束循環(huán)。使用前綴--意味著最后的一次循環(huán)迭代是發(fā)生在當(dāng)i等于0的時(shí)候。如果我們改變改變一下使用后綴的，那么循環(huán)迭代的最后一次發(fā)生在當(dāng)i等于-1的時(shí)候，這樣就會發(fā)生錯(cuò)誤，因?yàn)閿?shù)組的下標(biāo)是從0開始的，-1是一個(gè)無效的數(shù)組下標(biāo)。

　　程序中其它兩個(gè)循環(huán)使用了后綴的++。在兩個(gè)例子中，使用前綴或者后綴是沒有問題的。當(dāng)其中一個(gè)運(yùn)算符號返回的數(shù)值沒有用到，則約定使用后綴的。

下面的表格總結(jié)自增/自減運(yùn)算符：

3.2.2 關(guān)系與條件運(yùn)算符

關(guān)系運(yùn)算符是比較兩個(gè)數(shù)值并決定它們的關(guān)系。比如!=在如果兩個(gè)運(yùn)算對象不相等的情況下返回true。以下這個(gè)表格總結(jié)了關(guān)系運(yùn)算符：

接下來介紹一個(gè)例子RelationalDemo。
下面是一個(gè)例子RelationalDemo，它定義了三個(gè)整型數(shù)并且使用關(guān)系運(yùn)算符來比較它們，如下：

public class RelationalDemo { public static void main(String[] args) { //定義幾個(gè)數(shù) int i = 37; int j = 42; int k = 42; System.out.println("變量數(shù)值..."); 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 } }

程序的輸出為：

變量數(shù)值...

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

關(guān)系運(yùn)算符經(jīng)常用在條件運(yùn)算符中來構(gòu)造更復(fù)雜的判斷表達(dá)式。JAVA變成語言支持六種條件運(yùn)算符：五個(gè)雙元運(yùn)算符和一個(gè)單元運(yùn)算符，如下表所示；

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

　　0 <= index && index < NUM_ENTRIES

　　這里注意在一些實(shí)例中，第二個(gè)運(yùn)算對象可能不用運(yùn)算，因?yàn)槿绻谝粋€(gè)運(yùn)算對象是false，則結(jié)果就一個(gè)是false，因此不用在計(jì)算第二個(gè)運(yùn)算對象了。你看看以下的代碼：

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

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

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

3.2.3 移位和邏輯運(yùn)算符

　　移位運(yùn)算符通過對第一個(gè)運(yùn)算對象左移或者右移位來對數(shù)據(jù)執(zhí)行位操作。下面的這個(gè)表總結(jié)了JAVA編程語言中有效的移位運(yùn)算符。

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

13 >> 1;

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

　　當(dāng)它的運(yùn)算對象為數(shù)字的時(shí)候，&運(yùn)算符為每一個(gè)運(yùn)算對象的每位執(zhí)行按位AND功能。AND在運(yùn)算對象的相應(yīng)位為1的時(shí)候結(jié)果才為1，其余情況結(jié)果都為0，如下表所示：

　　假如你要對數(shù)13和12作AND操作，比如13&12。運(yùn)算的結(jié)果為12，因?yàn)?2的二進(jìn)制為1100，遙13的二進(jìn)制為1101，具體運(yùn)算過程如下所示：

1101 //13

& 1100 //12

------

1100 //12

　　如果兩個(gè)運(yùn)算對象都為1，AND的結(jié)果就為1，或者結(jié)果就為0。因此，當(dāng)你對兩個(gè)運(yùn)算對象執(zhí)行AND操作的時(shí)候，你可以看到左邊的兩位結(jié)果位1，而右邊兩位的結(jié)果為0。當(dāng)兩個(gè)操作對象都位數(shù)字的時(shí)候，|操作符執(zhí)行或操作，而^執(zhí)行異或操作?；虿僮魇钦f只要有一個(gè)運(yùn)算對象為1結(jié)果就為1。下面的表格給出了或操作的結(jié)果：

　　異或是指當(dāng)運(yùn)算對象不同時(shí)結(jié)果才為1，或者結(jié)果為0。下表給出了異或運(yùn)算符的計(jì)算結(jié)果：

　　最后，補(bǔ)運(yùn)算符號是將運(yùn)算對象的每一位倒置，即如果原來的位位1結(jié)果就為0，如果原來的位為0則結(jié)果為1。

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

static final int VISIBLE = 1;

static final int DRAGGABLE = 2;

static final int SELECTABLE = 4;

static final int EDITABLE = 8;

int flags = 0;

　　為了當(dāng)有事物變得可見要設(shè)置"visible"標(biāo)識，你可以使用以下的語句：

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."); } } }

這個(gè)程序的輸出為：

Flags are Visible and Draggable.

Flags are now also Editable.

3.2.4 賦值運(yùn)算符

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

// 整型

byte largestByte = Byte.MAX_VALUE;

short largestShort = Short.MAX_VALUE;

int largestInteger = Integer.MAX_VALUE;

long largestLong = Long.MAX_VALUE;

//實(shí)數(shù)

float largestFloat = Float.MAX_VALUE;

double largestDouble = Double.MAX_VALUE;

//其它類型

char aChar = 'S';

boolean aBoolean = true;

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

i = i + 2;

當(dāng)然你還可以這樣來進(jìn)行簡化，主要是用了+=運(yùn)算符：

i += 2;

上面的兩行是等價(jià)的。

下面的表列出了所有的賦值運(yùn)算符和它們的等價(jià)形式：

3.2.5 其它的運(yùn)算符

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

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

下面逐個(gè)介紹：

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

這個(gè)?:運(yùn)算符是一個(gè)條件運(yùn)算符號，它是一個(gè)簡化的if-else語句：

op1 ? op2 : op3

這個(gè)?:運(yùn)算符號在op1為true的時(shí)候返回op2，或者返回op3。

(2) [ ] 運(yùn)算符

你可以使用方括號來聲明數(shù)組、創(chuàng)建數(shù)組并且訪問數(shù)組中一個(gè)特殊的元素。以下是數(shù)組聲明的一個(gè)例子：

float[] arrayOfFloats = new float[10];

前面的代碼聲明了一個(gè)數(shù)組來容納10個(gè)浮點(diǎn)型的數(shù)字。以下給出訪問第7個(gè)元素的方法：

arrayOfFloats[6];

這里注意第7個(gè)元素的下標(biāo)是6，因?yàn)榈谝粋€(gè)元素的下標(biāo)為0.

（3）.運(yùn)算符

點(diǎn)運(yùn)算符是訪問對象實(shí)例或者類的類成員函數(shù)。

（4）（）運(yùn)算符

當(dāng)聲明或者調(diào)用一個(gè)方法的時(shí)候，你可以在(和)之間列出方法的參數(shù)。你可以利用()來指定一個(gè)空的參數(shù)列表。

• (type)運(yùn)算符

這個(gè)運(yùn)算符可以將數(shù)值轉(zhuǎn)換為一個(gè)指定的類型。

• new運(yùn)算符

你可以使用new運(yùn)算符號來創(chuàng)建一個(gè)新對象或者一個(gè)新數(shù)組。以下是一個(gè)從java.lang包中的Interger類創(chuàng)建新的整型對象：

Integer anInteger = new Integer(10);

（6）instanceof運(yùn)算符

instanceof操作符測試第一個(gè)運(yùn)算對象是否是第二個(gè)運(yùn)算對象的實(shí)例，比如：

op1 instanceof op2

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

3.3 表達(dá)式、語句和塊

　　這一節(jié)教程討論怎樣將運(yùn)算符和變量集中到表達(dá)式中去。表達(dá)式是代碼的構(gòu)建塊。你同樣還可以學(xué)到怎樣構(gòu)造語句和語句塊。

變量和運(yùn)算符是程序的基本構(gòu)造塊。你可以集中變量和運(yùn)算符來組成表達(dá)式（表達(dá)式是執(zhí)行計(jì)算并返回?cái)?shù)值的代碼段）。通過使用大括號{和}你可以創(chuàng)建代碼塊。

3.3.1表達(dá)式

　　表達(dá)式執(zhí)行程序的工作。跟其它事情一樣，表達(dá)式用于計(jì)算和為變量賦值并且?guī)椭刂瞥绦虻膱?zhí)行流程。表達(dá)式任務(wù)有兩重：利用表達(dá)式的元素來執(zhí)行計(jì)算；返回計(jì)算結(jié)果的數(shù)值。

　　就象前面的章節(jié)討論的，運(yùn)算符要返回一個(gè)數(shù)值，因此運(yùn)算符的使用就是一個(gè)表達(dá)式。如下的程序：

…

char aChar = 'S';

boolean aBoolean = true;

// 顯示

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

...

if (Character.isUpperCase(aChar)) {

...

}

每一個(gè)條語句執(zhí)行一個(gè)操作并且返回一個(gè)數(shù)值。如下表所示：

　　表達(dá)式返回?cái)?shù)值的數(shù)據(jù)類型依靠于使用在表達(dá)式中的元素。這個(gè)表達(dá)式aChar = 'S'返回一個(gè)字符型，因?yàn)橘x值操作符返回相同數(shù)據(jù)類型（操作符和aChar以及'S'都是字符型）的數(shù)值。從其它表達(dá)式可以看出，表達(dá)式可以返回一個(gè)boolean數(shù)值、字符串等等。

　　只要表達(dá)式子需要的數(shù)據(jù)類型匹配其它的數(shù)據(jù)類型，JAVA編程語言允許你將多個(gè)小的表達(dá)式構(gòu)造復(fù)合的表達(dá)式。下面是一個(gè)復(fù)合的表達(dá)式例子：

x * y * z

　　在這個(gè)消息的例子中，各個(gè)運(yùn)算對象的先后順序不是很重要因?yàn)槌朔ǖ慕Y(jié)果跟順序無關(guān)。但是這對于其它表達(dá)式有時(shí)并不適合。例如，下面的表達(dá)式就跟順序有關(guān)了，它關(guān)系到是哪個(gè)先乘還是先加的問題：

x + y / 100

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

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

　　如果你沒有在復(fù)合的表達(dá)式中指定各個(gè)運(yùn)算的順序，那么運(yùn)算的順序?qū)⑷Q于表達(dá)式中的運(yùn)算符的優(yōu)先順序，即優(yōu)先順序高的先進(jìn)行計(jì)算。比如除法運(yùn)算符的優(yōu)先順序高于加法運(yùn)算符，所以以下的兩條語句是等價(jià)的。

x + y / 100

x + (y / 100)

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

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

　　當(dāng)相同優(yōu)先級的運(yùn)算符出現(xiàn)在相同的表達(dá)式中，所有的雙元運(yùn)算符的運(yùn)算順序是從左到右，而賦值運(yùn)算符是從右到左計(jì)算的

3.3.2 語句

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

1. 賦值語句

    

    

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

    

    

3. 方法調(diào)用

    

    

4. 對象創(chuàng)建表達(dá)式

    

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

aValue = 8933.234; //賦值語句

aValue++; //增量語句

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

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

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

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

double aValue = 8933.234; // 聲明語句

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

3.3.3 塊

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

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 控制流程語句

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

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

char c;

...

if (Character.isUpperCase(aChar)) {

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

}

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

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

控制流程語句描述

{

語句（參數(shù)）

}

如果塊中只有一條語句，大括號{和}并不是必要的。但是這里推薦使用{和}，因?yàn)榇a會更容易閱讀，避免在修改代碼的時(shí)候發(fā)生錯(cuò)誤。

控制流程語句有：

1. while和do-while語句

    

    

2. for語句

    

    

3. if-else語句

    

    

4. switch語句

    

    

5. 異常處理語句

    

    

6. 分支語句

    

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

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

　　你可以使用while語句當(dāng)條件保持為true的時(shí)候，持續(xù)執(zhí)行語句塊。While語句的通常語法為：

while (expression) {

statement

}

　　首先，while語句執(zhí)行表達(dá)式，它將返回一個(gè)boolean數(shù)（true或者false）。如果表達(dá)式返回true，while語句執(zhí)行相應(yīng)的語句。While語句繼續(xù)測試表達(dá)式并執(zhí)行塊代碼直到表達(dá)式返回false。

　　下面給出一個(gè)例程WhileDemo，它使用while語句來瀏覽字符串的各個(gè)字符并復(fù)制字符串直到程序找到字符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);

}

}

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

do {

statement(s)

} while (expression);

　　不象while語句，do-while語句是先執(zhí)行循環(huán)中的語句后再計(jì)算表達(dá)式的，所以do-while語句就至少執(zhí)行一次語句。

　　下面是對上面的程序利用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);

}

}

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

3.4.2 for語句

for語句提供了一個(gè)簡便的方法來進(jìn)行循環(huán)。For語句的語法如下：

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

語句

}

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

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

...

}

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

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();

}

}

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

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

3.4.3 if-else語句

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

if (DEBUG) {

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

}

上面是一個(gè)簡單的if語句的例子?？偟谜f來，if語句的語法格式為：

if (表達(dá)式) {

語句（參數(shù)）

}

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

. . .

// response is either OK or CANCEL depending

// on the button that the user pressed

. . .

if (response == OK) {

// 在這里添加執(zhí)行OK動作的代碼

} else {

// 在這里添加執(zhí)行Cancel動作的代碼
如果if部分為false，則執(zhí)行else塊。另外一種else語句的格式是else if，它根據(jù)執(zhí)行另外的表達(dá)式執(zhí)行語句。一個(gè)if語句可以跟著任意個(gè)else if語句，但只能有一個(gè)else語句。下面是一個(gè)例程IfElseDemo，它根據(jù)測試分?jǐn)?shù)的數(shù)值來指定一個(gè)等級：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
這時(shí)你可以注意到testscore的數(shù)值可以滿足組合if條件76 >= 70 and 76 >= 60，但是當(dāng)系統(tǒng)處理組合if語句的時(shí)候，一旦條件滿足，適當(dāng)?shù)恼Z句就將被執(zhí)行(grade = 'C';)，并且不需要計(jì)算剩余的條件控制就跳出if語句。JAVA編程語言支持運(yùn)算符?:，它是一個(gè)簡化的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.");

}

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

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

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

"case.");

　　如果這個(gè)isUpperCase方法返回true，這個(gè)?:運(yùn)算符返回字符串"upper" ?；騽t，它就返回字符串"lower"
3.4.4 switch語句

　　使用switch語句可以根據(jù)一個(gè)整型表達(dá)式有條件地執(zhí)行語句。下面的例程SwitchDemo，聲明了一個(gè)整型變量month，它的數(shù)值代表了月份。這個(gè)程序顯示了月份的名字，主要是根據(jù)month的數(shù)值并且使用了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;

}

}

}

　　這個(gè)switch語句計(jì)算它的表達(dá)式，在這個(gè)例子中是計(jì)算month的數(shù)值，然后計(jì)算適當(dāng)?shù)腸ase 語句。這樣，程序的輸出為：August。

當(dāng)然，你可以使用if語句來實(shí)現(xiàn)它：

int month = 8;

if (month == 1) {

System.out.println("January");

} else if (month == 2) {

System.out.println("February");

}

. . .

　　決定使用if語句還是switch語句的關(guān)鍵主要是根據(jù)可讀型以及其它因素。if語句可以在更大范圍或者條件來決定，而switch只有根據(jù)單個(gè)整型變量來做決定。同時(shí)，提供給case語句的數(shù)值必須是單一的。另外一點(diǎn)是，switch語句在每個(gè)case之后有一個(gè)break語句。每個(gè)break語句終止了swtich語句，并且控制流程繼續(xù)switch塊之后的第一個(gè)語句。break語句是必須的，因?yàn)闆]有它，case語句就會失效，也就是說，沒有break語句，控制流程按順序執(zhí)行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); } }

這個(gè)程序的輸出為：

Number of Days = 29

　　最后的break語句是不需要的，因?yàn)榱鞒虒⑻鰏witch語句了。但是，我們推薦使用為最后一個(gè)case語句使用一個(gè)break以防你需要還增加更多的case語句。這就使得更容易修改代碼以及減少錯(cuò)誤。

　一般地，你可以使用break來在分支語句中終止循環(huán)。最后你可以在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編程語言提供一個(gè)異常機(jī)制用來幫助程序報(bào)告和處理錯(cuò)誤。當(dāng)一個(gè)錯(cuò)誤發(fā)生的時(shí)候，程序就產(chǎn)生一個(gè)異常。即正常的程序路程被中斷并且系統(tǒng)緩建想找到一個(gè)異常處理：一個(gè)能處理特殊類型錯(cuò)誤的代碼塊。這個(gè)異常福利可以視圖恢復(fù)錯(cuò)誤或者如果它決定了錯(cuò)誤是不可修復(fù)的，它提供一個(gè)較好退出程序的方法。

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

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

    

    

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

    

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

下面是這三個(gè)語句的語法格式：

try {

語句（參數(shù)）

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

語句（參數(shù)）

} finally {

語句（參數(shù)）

}

上面簡述了由JAVA編程語言提供的用來報(bào)告和處理錯(cuò)誤的語句。但是，另外的因素和原因，比如運(yùn)行和檢查異常之間的差異以及異常類的分級結(jié)構(gòu)（代表異常的不同種類）在使用異常機(jī)制的時(shí)候起著重要的作用。

3.4.6 分支語句

JAVA編程語言支持下面的三種分支結(jié)構(gòu)：

break語句

continue語句

return語句

（1）break語句

　　break語句有兩種形式：未標(biāo)志的和標(biāo)志的。你在前面就已經(jīng)看過了未標(biāo)志的break語句。一個(gè)未標(biāo)志的break語句終止swtich語句，控制流程馬上轉(zhuǎn)到switch語句下方的語句。下面的例程BreakDemo，它包含了一個(gè)for循環(huán)查找數(shù)組中特定的數(shù)值：

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");

}

}

}

　　當(dāng)數(shù)值被找到的時(shí)候，這個(gè)break語句終止了for循環(huán)?？刂屏鞒叹娃D(zhuǎn)到for語句的下面的語句繼續(xù)執(zhí)行。這個(gè)程序的輸出為： Found 12 at index 4
　未標(biāo)志形式的break語句被用來終止內(nèi)部的switch、for、while或者do-while。而標(biāo)志形式的break語句終止一個(gè)外部的語句，它是通過在break語句中使用一個(gè)標(biāo)志來實(shí)現(xiàn)的。下面的例程BreakWithLabelDemo跟前面的例子有點(diǎn)相似，只不過它是在一個(gè)兩維數(shù)組中搜索一個(gè)數(shù)值。利用兩個(gè)嵌套的for循環(huán)遍歷了整個(gè)數(shù)組。當(dāng)數(shù)值被找到了，標(biāo)志形式的break語句就終止標(biāo)志的search語句，這個(gè)search語句是在for循環(huán)外部的：

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");

}

}

}

這個(gè)程序的輸出為：

Found 12 at 1, 0

　　這個(gè)語法看起來可能有點(diǎn)費(fèi)解。break語句終止了標(biāo)志語句，它不能將控制流程轉(zhuǎn)到這個(gè)標(biāo)志處?？刂屏鞒萄杆賹?biāo)志（終止的）后面的語句。

（2）continue語句

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

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);

}

}

這個(gè)程序的輸出為：

Found 9 p's in the string.

Peter PiPer Picked a Peck of Pickled PePPers