·本章學習目標
熟悉Java編程的基礎知識
掌握Java語言的基本數據類型、操作符、表達式
掌握Java程序的流程控制語句
熟悉并學會初步使用Java編程環境
·本章學習內容
數據類型
常量、變量與表達式
數據類型的轉換
Ø 數組
Ø 流程控制語句
§2.1 數據類型
對于程序中的數據，編譯程序會為其分配一塊內存空間，內存空間的大小由該數據的數據類型來決定。
Java語言的數據類型分為兩大類：基本類型（primitive type）和引用類型（reference type），相應也就有兩種類型的變量。
2.1.1基本數據類型
基本類型是Java語言中預定義、長度固定、不能再分的類型，數據類型的名字也被當作關鍵字保留，且都小寫。
在Java語言中，所有數據都必須嚴格定義其數據類型，且所有的變量都必須有初始值或默認值。Java語言的基本數據類型參見下頁表。
|
基本數據類型
|
占內存
|
取值范圍
|
默認值
|
|
數值型
|
整型
|
byte
|
1字節
|
- 128 ~ 127
|
(byte)0
|
|
short
|
2字節
|
- 32768 ~ 32767
|
(short)0
|
|
int
|
4字節
|
- 2147483648 ~ 2147483647 （即-215 ~ 215-1）
|
0
|
|
long
|
8字節
|
- 9223372036854775808L~ 9223372036854775807L （即-231 ~ 231-1）
|
0L
|
|
浮點型
|
float
|
4字節
|
對于負數：- 3.402823E38 ~ - 1.401298E-45
對于正數：1.401298E-45 ~ 3.402823E38
|
0.0F
|
|
double
|
8字節
|
對于負數：- 1.79769313486232E308 ~
- 4.94065645841247E-324
對于正數：4.94065645841247E-324~1.79769313486232E308
|
0.0
|
|
字符型
|
char
|
2字節
|
unicode字符，用單引號括起來
|
'"u0000'
|
|
布爾型
|
boolean
|
1字節
|
true，false
|
false
|
關于基本數據類型作幾點說明：
由于字符皆用16個二進制位表示，所以Java語言設計了一個用8個二進制位來表示的byte數據類型，可用來表示AscII碼。
Java語言中，布爾型（boolean）數據不再與整數相關，而是獨立作為一種數據類型，并且不能與整數有任何自動轉換關系。
Java語言中，char是唯一的無符號表示的數據類型。如果將char轉換為int或者short，很可能得到一個負數。
浮點型的數據被0除時不會報錯，而是輸出“Infinity”，編程時一定要小心。
與很多其他編程語言中的字符串（String）和數組不同，Java語言將其作為對象處理，而不是作為基本數據類型。
與基本數據類型相對應的是引用數據類型即引用變量，包括對象、字符串、數組等。例如，Java語言通過類庫中定義的String類與StringBuffer類處理字符串，所以字符串具有引用變量的特征。
引用類型的變量是由參數來控制的。當聲明一個引用類型的變量之后，內存只分配一個空間用來存放此變量的地址，當調用它時只是將此對象存儲地址傳過去。只有當用new命令正式申請內存空間或直接初始化時，才會得到用來存放其值的空間。
2.1.2引用數據類型
引用類型的變量（即對象）的內存分配圖：
2.1.3數值類型間的轉換
Java在運算時總是要進行數據類型的檢查，如果數據類型不一致，則按照某種規則進行轉換，然后按照轉換后的數據類型運算。如果這種轉換不能進行，則會報告出錯信息。
Java的自動數據類型轉換只能完成由低級數據類型向高級數據類型的轉換，也就是只能完成由占用內存少的數據類型向占用內存多的數據類型的轉換。
設c = a + b，當a與b數據類型不同時自動數據類型轉換如表2-3所示。
|
操作數a的數據類型
|
操作數b的數據類型
|
操作數b轉換后的數據類型以及運算結果c的數據類型
|
|
int
|
byte或short
|
int
|
|
long
|
byte或short或int
|
long
|
|
float
|
byte或short或int或long
|
float
|
|
double
|
byte或short或int或long
|
double
|
|
int
|
char
|
int
|
如果需要由高級數據類型向低級數據類型的轉換，就必須使用強制數據類型的轉換，具體的方法是在需要轉換的數據前面加上欲轉換的數據類型，并用括號括起來。
【例】整型與浮點型的轉換
float a = 1.414;
int b = (int) a;
其結果是b被賦值為1。
強制數據類型轉換可能會導致數據精度的降低或導致數據溢出，要慎重使用。上例就是一個損失了數據精度的例子。
除了使用上述方法進行強制數據類型的轉換之外，邏輯型數據與其他基本數據類型的轉換需要一些技巧，下例是邏輯型與整型相互轉換的例子。
【例】邏輯型與整型的轉換
boolean b = false;
int i = 4;
b = ( i != 0 ); //把整型轉換為邏輯型使b=true
i = ( b ) ? 1 : 0; //把邏輯型轉換為整型使i=1
2.2 標識符和關鍵字
標識符可以理解為名字。在Java語言中，常量名、變量名、類名、對象名等都是標識符。標識符的命名遵守以下規則：
標識符由字母、數字、下劃線或美元符$組成。
標識符的第一個字符必須是字母、下劃線或美元符，從第二個字符開始也可以是數字。
不能以Java的關鍵字作為標識符。
Java語言對大小寫是敏感的，即大寫字符與小寫字符被看作是不同的字符。
標識符可以任意長，在機器內部用Unicode字符集表示。
關鍵字就是保留字，關鍵字不能再被用做標識符。在Java語言中有近60個關鍵字，關鍵字分為如表所示的幾類。
|
關鍵字類型
|
關鍵字
|
|
內構類型關鍵字
|
boolean true false char byte short int long float double void
|
|
表達式關鍵字
|
null this new super
|
|
語句關鍵字
|
選擇語句
|
if else switch case break default
|
|
循環語句
|
for do while continue
|
|
控制轉移語句
|
return throw
|
|
防衛語句
|
synchronized try catch finally
|
|
修飾符關鍵字
|
static abstract final private protected public transient volatile
|
|
用于類、方法及其相關目的的關鍵字
|
class instanceof throws native
|
|
用于擴展類構筑模塊的關鍵字
|
extends interface implements package import
|
|
保留日后使用的關鍵字
|
cast const future generic goto inner operator outer rest var
|
2.3 常量和變量
2.3.1變量
變量是在程序運行過程中其值能夠改變的量，通常用來保存計算結果或中間數據。在Java語言中變量必須先聲明后使用，并且應當為變量賦初始值。
1. 變量的聲明
type identifier1[, identifier2, …]
type為數據類型；identifier1[, identifier2, …]為一個或多個變量的標識符，即變量名。
【例】聲明變量
int x, y; //定義 x, y兩個整 型變量
float a, b, c; //定義a, b, c三個浮點型變量
2．為變量賦初值
定義變量之后要為變量賦初始值，具體做法是使用賦值語句。
【例】為以上定義的整型變量x、y和浮點變量a、b、c賦初值的語句。
x = 5;
y = x + 4;
a = 4.23F;
b = 2 * a;
c = a * a + b;
如果聲明變量以后沒有賦初值，則會產生一個“變量還未被初始化”的錯誤。
3．在聲明變量時為變量賦初值
為變量賦初始值也可以在聲明變量時進行，以下是把以上定義、賦初值兩個步驟合并的做法。
【例】聲明變量的同時賦初值
int x=5, y=x+4; //定義 x, y兩個整型變量并賦初值
float a=4.23F, b=2*a, c=a*a+b; //定義a, b, c三個浮點型變量并賦初值
4．變量的有效范圍與生存周期
變量的有效范圍或生存周期就是聲明該變量時所在的語句塊，也就是用一對大括號{}括起的范圍。一旦程序的執行離開了定義它的語句塊，變量就變得沒有意義，也就不再被使用了。
2.3.2常量
常量是在程序運行過程中其值始終不改變的量。常量分為直接常量和符號常量兩種。直接常量就是不使用任何標識符直接引用其值的常量。
1．直接常量的后綴
使用數值型直接常量有時會引起多義性。例如直接常量“0”，就可能是byte或short或int或long或float或double類型的。為了避免這種情況的發生不加后綴時默認為int類型，此外Java為long、float和double類型的直接常量規定了使用后綴的方式，而對于byte和short類型的直接常量則只能使用強制數據類型轉換，具體內容列于下頁表中。
|
數制
|
表示方法
|
可表示的數據范圍
|
|
十進制
|
默認的數制
|
|
|
八進制
|
以0開頭的數字，數字由0到7組成
|
0000~0377相當于十進制的0~255
|
|
十六進制
|
以0x開頭的數字，數字由0到F組成
|
0x0000~0xFFFF或0x00000000~0xFFFFFFFF
|
3．轉義字符
為了更方便地在字符串中表示一些特殊字符，Java定義了轉義字符“"”，緊接在轉義字符右邊的字符被解釋成其他含義，或者說“"”及其右邊的字符一起代表一個特殊的字符。這種方法給編程帶來方便。表2-13給出了轉義字符代表的意義。
|
轉義字符
|
對應的unicode碼
|
解釋
|
|
'"b'
|
'"u0008'
|
退格
|
|
'"t'
|
'"u0009'
|
制表符
|
|
'"n'
|
'"u000A'
|
換行
|
|
'"f'
|
'"u000C'
|
表格符
|
|
'"r'
|
'"u000D'
|
回車
|
|
'""'（雙引號）
|
'"u0022'
|
雙引號
|
|
'"''（單引號）
|
'"u0027'
|
單引號
|
|
'""'
|
'"u005C'
|
反斜杠
|
|
'"000'（3位八進制數）
|
'"000'
|
能表示所有AscII字符
|
|
'"u0000'（4位十六進制數）
|
'"u0000'
|
能表示所有unicode字符
|
4．符號常量
符號常量的定義與變量類似，也是先定義一個標識符，然后通過標識符讀取其值的常量。符號常量一經定義，其值不能被改變，這是與變量的根本區別。符號常量也象變量一樣，每一個符號常量都有其數據類型和作用范圍。按照一般的習慣，常量標識符中的英文字母使用大寫字母。定義常量的方法是：
final type identifier1 = value1 [, identifier2 = value2, …]
其中修飾符final表示定義的是常量；type為數據類型；identifier1, identifier2, …為一個或多個常量的標識符，即常量名；value1，value2, …是常量的值。
【例】定義符號常量
final int x = 100, y = 200; //定義兩個整型常量x, y
final float a = 0, b = 2.355; //定義兩個浮點型常量a, b
2.4 運算符
2.4.1算術運算符
算術運算符是大家所熟識的。主要有兩點需要說明：
求余運算符%的兩個操作數，例如a%b中的a與b要求均為整型數據，其結果亦為整數。例如7%3=4，10%5=0。
對于加減乘除4個運算符，如果兩個操作數屬于同一種數據類型，其結果亦為此數據類型，如3*5=15，6/2=3。如果a與b的數據類型不同，則在Java中占用不同的字節數，如2*1.4=2.8，3.6/3=1.2等，其結果的數據類型與所占字節數多的數據類型相同。實際上Java在執行時，先將其中字節數少的操作數保存成與另一個操作數相同長度的形式，然后進行運算。
運算符就是進行某種運算的標識符號。
Java語言特別強調運算符執行順序的概念。Java語言對運算符的優先級、結合性與求值順序作了明確的規定。
|
算術運算符
|
說 明
|
|
+
|
正值運算符、加法運算符
|
|
-
|
負值運算符、減法運算符
|
|
*
|
乘法運算符
|
|
/
|
除法運算符
|
|
%
|
求余運算符
|
2.4.2自增、自減運算符
++、 --運算符的種類與用法如表所示。這類運算符常用于控制循環變量。
|
運算符
|
名稱
|
說明
|
|
++i
|
前自增
|
i參與相關運算之前先加1后參與相關運算
|
|
i++
|
后自增
|
i先參與其相關運算，然后再使i值加1
|
|
--i
|
前自減
|
i參與相關運算之前先減1后參與相關運算
|
|
i--
|
后自減
|
i先參與其相關運算，然后再使i值減1
|
一般說來，++i與i++都是使i=i+1，而--i與i--都是使i=i-1，但注意自增、自減運算符放在變量前還是放在變量后的不同。
前自增（減）時，先使變量加1或減1后，再去參與其它運算；后自增（減）時，先讓變量參與運算，然后再對當時的變量值加1或減1。
【例】int x = 2; int y = (++x)*3; 則x，y的值分別為3，9
先使x加1，然后執行乘法運算，最后賦值給y。
【例】int x = 2; int y = (x++)*3; 則x，y的值分別為3，6
先讓x值參與乘法運算，然后x自加1，最后將乘法運算結果賦給y。
自增、自減運算符只能用于變量，而不能用于常量和表達式，如8++與(a+c)++是沒有意義也是不合法的。
自增、自減運算符的結合性為自右至左，而且只作用于它所操作的變量，絲毫不影響該變量參與其它運算。
【例】設i原值為4，則執行 k=(i++)+(i++)+(i++); 后，i和k的值分別多少？
k值為12，i值為7，這是因為i++為變量后自增，所以i先參與其相它運算，即k=i+i+i=12。然后，i再執行變量后自增運算，按執行順序自左至右，共自增3次，故i值為7。
同樣道理，設i值為4，執行 g=(++i)+(++i)+(++i); 后，i和k的值分別多少？
i值為7，g值為21，即先對變量i進行三次增值后，再執行連加運算，得到g值。
2.4.3關系運算符
關系運算進行比較運算，通過兩個值的比較，得到一個boolean（邏輯）型的比較的結果，其值為“true”或“false”。在Java語言中“true”或“false”不能用“0”或“1”來表示，而且這兩個邏輯值必須用小寫“true”與“false”。
|
優先級
|
運算符
|
名稱
|
用途舉例
|
|
高
|
instanceof
|
實例為
|
if ( v instanceof convertible)
|
|
<
|
小于
|
a<b，3<2
|
|
>
|
大于
|
a>b，45>44
|
|
<=
|
小于等于
|
a<=b，23<=23
|
|
>=
|
大于等于
|
a>=b，23>=23
|
|
低
|
==
|
等于
|
x==y，x==5
|
|
!=
|
不等于
|
x!=y，x!=5
|
關系運算符常常用于邏輯判斷，如用在if結構控制分支和循環結構控制循環等處。7個關系運算符中，等于“==”和不等于“!=”同屬一個優先級，另外5個運算符同屬一個優先級，且前者的優先級別低于后者。在同一優先級中遵循自左至右的執行順序。關系運算符常常與下一節中的邏輯運算符混合用。
注意：“==”運算符和”=”運算符是完全不同的，前者是關系運算符，而后者是賦值運算符。
2.4.4邏輯運算符
Java語言中，提供了6種邏輯運算符，邏輯運算符的運算結果為邏輯型“true”或“false”。下表介紹了各種邏輯運算符。
|
優先級
|
運算符
|
名稱
|
用法舉例
|
說明
|
|
高
|
!
|
邏輯非
|
!a
|
a為真時得假，a為假時得真
|
|
低
|
&
|
邏輯與
|
a & b
|
a和b都為真時才得真
|
|
&&
|
簡潔邏輯與
|
a && b
|
a和b都為真時才得真
|
|
|
|
邏輯或
|
a | b
|
a和b都為假時才得假
|
|
||
|
簡潔邏輯或
|
a || b
|
a和b都為假時才得假
|
|
^
|
邏輯異或
|
a ^ b
|
a和b的邏輯值不相同時的真
|
邏輯運算表達式的執行順序為自左至右，邏輯非運算符“！”的優先級高于其它邏輯運算符。
Java語言中的位運算符如下表所示。
|
優先級
|
運算符
|
名稱
|
用法舉例
|
說明
|
|
見表
2-8
|
&
|
按位與
|
a & b
|
兩個操作數對應位分別進行與運算
|
|
|
|
按位或
|
a | b
|
兩個操作數對應位分別進行或運算
|
|
^
|
按位異或
|
a ^ b
|
兩個操作數對應位分別進行異或運算
|
|
~
|
按位取反
|
~ a
|
操作數各位分別進行非運算
|
|
<<
|
按位左移
|
a << b
|
把第一個操作數左移第二個操作數指定的位，溢出的高位丟棄，低位補0
|
|
>>
|
帶符號按位右移
|
a >> b
|
把第一個操作數右移第二個操作數指定的位，溢出的低位丟棄，高位用原來高位的值補充
|
|
>>>
|
不帶符號按位右移
|
a >>> b
|
把第一個操作數右移第二個操作數指定的位，溢出的低位丟棄，高位補0
|
2.4.5位運算符
【例】計算表達式的值
設short a = 0x2F34; short b = 0xE5081
（1）求a & b
（2）求a | b
（3）求a ^ b
（4）求a << 3
（5）求b >> 3
（6）求b >>> 3
計算時先把a和b化成16位的二進制的數，
a = 00101111 00110100，b = 11100101 00001000
然后進行按位運算后，再換算成16進制的數。
（1）換算成16進制，結果為0x2500。
（2）換算成16進制，結果為0xEF3C。
（3）換算成16進制，結果為0xCA3C。
（4）左移n位相當于原數乘以2的n次冪，并且左移比乘法快，所以有時用左移代替乘2的n次冪的運算。換算成16進制，結果為0x79A0。
（5）換算成16進制，結果為0xFCA1。
（6）換算成16進制，結果為0x1CA1。
如果兩個不同長度的數值做位運算，系統將二者的右端（即低位）對齊，同時將兩個操作數中長度較短者的高位用0補齊。
2.4.6條件運算符
條件運算符的使用方式由“?”和“:”連接的三個操作數構成，一般的形式為：
表達式1?表達式2:表達式3
上式執行的順序為：先求解表達式1，若為真，取表達式2的值作為最終結果返回，若為假，取表達式3的值為最終結果返回。
條件運算符的優先級僅高于賦值運算符。結合性為自左向右。
【例】設a = 5，b = 8，c = 1，d = 9，求下式的值。
( a > b ) ? a : ( c > d ) ? c : d
由于結合性為自右向左，故先計算( c > d ) ? c : d。因為1 > 9為false，故取d（= 9）為返回結果。此時，再求( a > b ) ? a : d，即最終結果為9。
2.4.7賦值運算符
賦值運算符把常量、變量或表達式的值賦給一個變量，賦值運算符用等號“=”表示。為了簡化、精練程序、提高編譯效率，可以在“=”之前加上其它運算符組成擴展賦值運算符。
使用擴展賦值運算符的一般形式為：
<變量><擴展賦值運算符><表達式>
其的作用相當于：<變量>=<變量><運算符><表達式>
其中，<賦值運算符>為“<運算符>=”。
下頁表給出了各種擴展賦值運算符的用法。
|
擴展賦值運算符
|
用法舉例
|
等效的表達式
|
|
+=
|
a += b
|
a= a + b
|
|
-=
|
a -= b
|
a = a - b
|
|
*=
|
a *= b
|
a = a * b
|
|
/=
|
a /= b
|
a = a / b
|
|
%=
|
a %= b
|
a = a % b
|
|
&=
|
a &= b
|
a = a & b
|
|
|=
|
a |= b
|
a = a | b
|
|
^=
|
a ^= b
|
a = a ^ b
|
|
<<=
|
a <<= n
|
a = a << n
|
|
>>=
|
a >>= n
|
a = a >> n
|
|
>>>=
|
a >>>= n
|
a = a >>> n
|
賦值運算符遵循從右至左的結合性，看如下的例子。
【例】已知整形變量a，b，c，計算以下各式的值。
a = b = c = 5;
a = 5 + ( c = 6 ) - ( d = 2 );
a + = a * = b - = ( a = 4 ) * ( b = 2 );
計算過程如下：
第一式相當于a = ( b = ( c = 5 ) )其結果使得a、b、c皆為5。
第二式的結果為d=2，c=6，a=9。
而第三式的計算過程是：
第1步：a = 4，b = 2
第2步：b = 2 - 4 * 2 = -6
第3步：a = a * b = 4 * -6 = -24
第4步；a = a + a = -24 - 24 = -48
2.4.8運算符的優先級和結合性
在Java語言中，每個運算符分屬于各個優先級，同時，每個運算符具有特定的結合性。有的具有左結合性，即自左至右的結合原則；有的具有右結合性，即自右至左的結合原則。運算符在表達式中的執行順序為：首先遵循優先級原則，優先級高的運算符先執行。在優先級同級的運算符之間遵守結合性原則，或自左至右，或自右至左。
下頁表給出了各種運算符的功能說明、優先級和結合性，絕大部分在以上各小節已經分別介紹過。需要補充說明的是，“+”除了作為正號運算符與加法運算符之外，還可以起到字符串的鏈接作用。
|
優先級
|
運算符
|
結合性
|
說明
|
|
1
|
, . ; ( ) [ ] {}
|
|
分隔符
|
|
2
|
++ -- !
|
右→左
|
自增、自減、非
|
|
3
|
* / %
|
左→右
|
乘、除、求余
|
|
4
|
+ -
|
左→右
|
加、減
|
|
5
|
<< >> >>>
|
左→右
|
左移、右移、右移補0
|
|
6
|
Instanceof < <= > >=
|
左→右
|
實例為、小于、小于等于、大于、大于等于
|
|
7
|
== !=
|
左→右
|
等于、不等于
|
|
8
|
&
|
左→右
|
位與
|
|
9
|
^
|
左→右
|
位異或
|
|
10
|
|
|
左→右
|
位或
|
|
11
|
&&
|
左→右
|
與
|
|
12
|
||
|
左→右
|
或
|
|
13
|
?:
|
左→右
|
條件運算
|
|
14
|
= *= /= %= += -= <<= >>= >>>= &= ^= |=
|
右→左
|
賦值
|
由于嚴格規定了優先級和結合性，Java語言能高效靈活地運用這些賦值運算符，同時也會使初學者困惑不解。以下再舉兩個例子說明。
【例】已知整形變量i，計算下式及變量i的值
( i = 4 ) * i++
計算過程：執行時變量i首先被賦值為4，后做乘法得16，這是整個表達式的值，同時由于i++使變量i自身的值為5。
從上表中可以看出，邏輯非優于算術運算符和關系運算符，而邏輯或和邏輯與低于關系運算符，所以，在進行邏輯表達式的求值時，應該注意區分操作數是作為算術運算對象、關系運算對象還是邏輯運算對象。
【例】求下面表達式的值
7 > 6 || 4 < 5 && 3.6 > 0.2
計算過程：
按照自左至右的執行順序，因為關系運算優先于邏輯運算，先得出7 > 6為true，則無論邏輯或下一個操作數為true還是false，邏輯表達式7 > 6 || 4 < 5值為真，此時得到true && 3.6 > 0.2，對于邏輯與而言，第一個操作數為真，還須判斷第二個操作數的值才能得出結果，而3.6 > 0.2得true，表達式化為true && true，最后得出此表達式最終結果為true。
2.5 表達式
表達式是由運算符、操作數以及方法調用組成的，用來說明運算過程并返回運算結果。表達式可以嵌套，表達式的計算根據運算符的優先級和結合性進行，當數據類型不一致時會自動進行數據類型的轉換，如果轉換不能進行，就會產生錯誤。
【例】分析以下程序的運算結果
int x = 2000000000, y = 20, z;
z = x * y / 100;
System.out.println("z="+z);
計算過程：如果按照一般數學運算的方法，結果應當是2000000000 * 20 / 100 = 400000000，但在計算機上運行的結果為13452943。其原因是當計算x * y時，因兩個操作數都是int型，結果也應當是int型，但40000000000超出int型的范圍，得到的是1345294336，除以100并化成int就是13452943。
若把程序中的第3行改為： z = x * ( y / 100);
也不能得到正確的結果，只能得到0。其原因是當計算y / 100時得0.2，結果應當是int型的，化成int就是0，所以最后輸出一個錯誤的結果0。
對于本例，只要把數據類型定義為long就能得到正確的結果，程序如下：
long x, y, z;
x = 2000000000;
y = 20;
z = x * y / 100;
System.out.println( "z=" + z );
由此看來，在設計程序時寧愿把數據類型設計得寬裕些，也不要計劃得過于緊張，以免這類“莫名其妙”的錯誤發生。
2.6 數組
2.6.1一維數組、
·一維數組的聲明
數組聲明的格式為：
類型 數組名[ ]； 或者 類型[ ] 數組名；
注：數組名為Java標識符。“[ ]”部分指明該變量是一個數組類型變量。
【例】int arr1[];
char[] arr2;
說明：聲明了名為arr1的整型數組和名為arr2的字符型數組。
·一維數組的創建
要用new操作來構造數組，即在數組聲明之后為數組元素分配存儲空間，同時對數組元素進行初始化。其構造格式如下：
數組名=new 類型[數組長度]；
例如，list=new int[3];
注：它為整型數據組list分配3個整數元素的內存空間，并使每個元素初值為0。
為簡化起見，還可以把數組的說明和構造合在一起，其格式如下：
類型數組名[ ]= new 類型[數組長度];
·數組的初始化
數組初始化就是為數組元素指定初始值。通常在構造數組時，Jave會使每個數組元素初始化為一個默認值。但在許多情況下，并不希望數組的初值為默認值，此時，就需要用賦值語句來對數組進行初始化。
【例】給一個長度為5的整形數組的元素依次賦值0，1，2，3，4，并倒序打印輸出該數組的元素值。
public class ArrTest{
public static void main(string args[]){
int i;
int a[] = new int[5];
for(i = 0; i < 5; i++)
a[i] = i;
for(i = a.length -1; i>=0; i--)
System.out.println(“a[“+i+”]=“+a[i]);
}
}
·數組元素的使用
數組元素的標識方式為：
數組名[下標]
其中下標為非負的整型常數或表達式，其數據類型只能為byte,short,int, 而不能為long。
若在Java程序中超出了對數組下標的使用范圍（例如，數組的最大下標為5，但是在程序中存取了下標為8或-4的元素），則在運行此程序時將出現如下錯誤信息：
Exception in thread″main″
java.lang.ArrayIndexOutOfBoundsException
2.6.2多維數組
·二維數組的說明與創建
二維數組說明的格式為：類型數組名[ ] [ ];
例如： int intArray[ ] [ ];
對二維數組來說，分配內存空間有下面幾種方法：
（1）直接為每一維分配空間，如：
int a[ ] [ ] = new int[2] [3];
該語句創建了一個二維數組a，其較高一維含兩個元素，下圖為該數組的示意圖。
|
A[0][0]
|
a[0][1]
|
a[0][2]
|
|
A[1][0]
|
a[1][1]
|
a[1][2]
|
從最高維開始，分別為每一維分配空間，如：
int b[ ][ ] = new int[2] [ ]; //最高維含2個元素，每個元素為一個整型數組
b[0] = new int[3]; //最高維第一個元素是一個長度為3的整型數組
b[1] = new int[5]; //最高維第二個元素是一個長度為5的整型數組
該數組的示意圖為：
|
b[0][0]
|
b[0][1]
|
B[0][2]
|
|
|
b[1][0]
|
b[1][1]
|
B[1][2]
|
b[1][3]
|
b[1][4]
|
注意：使用運算符new來分配內存時，多維數組至少要給出最高維的大小。
如果在程序中出現 int a2[ ] [ ] =new int[ ] [ ];
編譯器將要提示如下錯誤：
Array dimension missing
·二維數組元素的初始化
二維數組元素的初始化有兩種方式：
（1）直接對每個元素進行賦值；
（2）在說明數組的同時進行初始化。
·二數組元素的引用
對二維數組中每個元素，其引用方式為：
數組名[下標1] [下標2];
其中下標1、下標2為非負的整型常數或表達式，如：a[2] [3] 、cc[i+2][j*3 ](i,j為整數)等。同樣，每一維的下標取值都從0開始。
Java語言中的程序流程控制結構包括分支結構、循環結構、控制轉移結構和防護結構四類，其中防護結構是Java語言所特有的，將在以后章節中介紹。本節先介紹前三類結構。
2.7 程序流程控制結構
2.7.1分支結構
Java的選擇結構包括if結構和switch結構兩種。
1．If結構
if結構的基本形式是：
if (條件表達式) 語句1;
[ else 語句2; ]
其中，“else 語句體”可選。在if語句中條件表達式的值必須是一個邏輯型。如果表達式的值是非邏輯型，系統將會報錯。語句可以是一條語句，或用“{}”括起來的多條語句的語句體。
2. 嵌套的if結構
嵌套if結構的形式是：
if (條件表達式1) 語句1；
else if (條件表達式2) 語句2;
……
[ else 語句3; ]
如果不省略“else 語句3;”，這種嵌套的if結構總是只能滿足一個條件因而只能執行一條語句；
如果省略“else 語句3;”，這種嵌套的if結構可能滿足一個條件因而執行一條語句，也可能所有條件都不滿足因而一條語句也不執行。同基本形式的if結構一樣，各語句可以是一條語句，或是用“{}”括起來的語句體。
3．switch選擇結構
switch選擇結構的基本形式為：
switch (表達式){
case值1: {語句體1};[ break;]
case值2: {語句體2};[ break;]
……
case值n: {語句體n}; [break;]
[ defaultl: {語句體n+1}; [break;] ]
}
switch選擇語句的表達式的值應為一個byte、short、int、char類型的數值。
switch選擇結構的常用目的就是為了從眾多情況中選擇所希望的一種去執行，故而，每一分支語句中都用break語句作為結束。如果忽略掉break語句，程序將繼續測試并有可能執行下一分支，直到遇到break語句或當前switch語句體結束，這往往不是程序員所希望的。
switch選擇語句中可以有一個default語句作為其它情況都不匹配時的出口。
Java語言中有3種形式的循環結構，分別是for結構、while結構以及do…while結構。在Java語言中可以隨時說明局部變量加以利用，并且僅在說明的程序塊中有效。循環結構中常用此類局部變量作為循環變量，當循環結束時，局部變量亦被內存空間釋放掉，這種動態的分配內存的機制很方便，不易出錯且節約內存。
2.7.2循環結構
1．for循環結構
for循環結構的一般格式為：
for (循環初始值; 循環條件; 循環增長量){ 循環體 }
for循環結構中的初始值、測試條件及增長量皆由表達式組成，三者皆為可選的，既可以在for循環結構之前設定好循環初始值，也可以在for循環結構體內對增長量加以設定。如果連測試條件都沒有，那么將是無窮循環，如：
for( ; ; ){}
“循環初始值; 循環條件; 循環增長量”三者之間用分號“;”隔開，故每個部分可以有幾個表達式，每個表達式之間用逗號“，”隔開。如：
for(i = 0，j = 0; i + j < 100; i++, j += 2)
for結構常常臨時說明局部變量作為循環變量使用，當for循環結束時，這種臨時局部變量即失效。如：
for (int i=0; i<10; i ++) {}
2．while循環結構
while循環結構的表達形式為：
while (循環條件){ 語句體 }
其中“循環條件”為一個邏輯表達式。
while循環結構在每一次循環之前先計算邏輯表達式的值，如果為真，執行語句體；如果為假，轉而執行語句體的下一條語句。也就是說，語句體可能循環執行多次也可能一次也不被執行。
3．do…while循環結構
do…while循環結構的表達形式為：
do{
語句體
}while (表達式);
其中“循環條件”為一個邏輯表達式。與while循環結構不同的是，do…while循環結構的語句體至少被執行一次。也就是說，do…while循環結構先執行一次語句體，再計算邏輯表達式的值，如果為真，再去執行語句體；為假，執行下一段程序。
在分支結構和循環結構中有時需要提前繼續或提前退出分支結構和循環結構，為實現這一功能，要配合使用continue語句和break語句。下面介紹這兩個語句。
4．continue語句
continue語句有兩種形式：
continue;
continue 標號;
continue語句的作用就是提前繼續下一個循環，即：如果正在進行第N次循環，就增加循環變量，測試循環條件，如果符合，進入第N+1次循環。
第二種用法“continue標號;”用在希望結束內部循環而繼續外部循環，同時不希望外部循環從頭開始。就事先在外部循環處加上標號，并在循環體中用“continue標號;”語句實現這種跳轉。所謂標號由一個標識符加冒號組成。
【例】“continue 標號”的使用
計算年月。變量m表示月份，變量d表示日期。當m = 2且d = 28時，執行“continue months”語句，跳出內部循環，轉到標號months處，并開始執行m = 3的循環。程序如下：
months: for(int m=1; m<=12;m++){
for(int d=1; d<=31; d++){
if(m==2&&d==28)
continue months ;
……
}
}
5．break語句
break語句亦有兩種形式：
break;
break標號;
break語句用于for、while、do…while與switch結構中，其作用與continue語句正好相反。執行break語句時，程序跳轉到循環結構或選擇結構語句塊的結束處，執行下一條語句。
使用第二種用法“break標號;”時，應在程序中事先定義一個匹配的標號，且此標號必須在一個完整程序塊開始處。這一程序塊可以為任何語句，不一定是循環語句或switch語句，這與“continue標號;”中的標號位置不同，在continue中標號必須在外部循環開始處。
【例】“break 標號”的使用。
months: for ( int m = 1; m <= 12, m++ ){
for (int d = 1; d <= 31; d++ ){
if ( cost > budget )
break months;
……
}
}
2.7.3控制轉移語句
控制轉移語句有以下兩種表達形式：
return;
return (表達式);
控制轉移語句用于從方法中返回上一級程序。使用第二種形式能向上一級程序返回值一個返回值。若方法的返回值設定為“void”類型，則只能使用第一種返回形式。
最后，處理異常情況的“throw”語句也屬于控制轉移語句，將在第8章進行詳細介紹。
2.7.4其他語句
除了前面介紹的程序結構語句之外Java還使用其他幾種語句，其中有的在前面的例子中已經使用過了，現介紹如下。
1．方法調用語句
方法調用語句用于調用指定對象的指定方法，一般用法是：
對象名.方法名(參數表)
例如：System.out.println ( "Good!" )
就調用System.out 對象的println方法顯示一個字符串“Good!”。
2．表達式語句
表達式也是Java語句，例如以下語句都是表達式語句：
a = b + c;
c = (a++) + (++b) + a * 2 + b * b
3．空語句
空語句就是只有一個分號的語句，空語句什么也不做，只用在有意識形成空循環時。例如以下語句空循環100次。
for ( int i = 1 , i <= 100, i++ );
4．復合語句
復合語句就是由{}括起來的由若干語句組成的語句塊。
2.8 注釋
注釋是程序員為增強程序可讀性常用的一種輔助手段，良好注釋的習慣將有助于對程序的理解和程序設計清晰度的提高，便于程序的日后維護。
Java語言有3種注釋方式：
以“//”開始的注釋。即可用于一行的行尾，也可單獨占用一行。
以“/*”開始到下一個“*/”結束的注釋，這種注釋往往占用多行。
以“/**”開始，到“*/”結束的注釋。這種注釋是為自動產生程序文檔設計的。
Java語言中注釋不能嵌套。例如在“/*”與“*/”之間出現了“*/”，就會產生錯誤。
·小結
本章介紹的內容是Java語言的重要組成部分。學習本章以后應當能正確地使用關鍵字和標識符，能按照語法要求正確地書寫程序。
掌握各種運算符的功能、使用方法和優先級，能使用常量、變量、運算符正確地組成表達式。
掌握使用if和switch選擇語句形成程序分支的方法。
掌握使用for，while，do結構形成循環程序的方法。
理解控制轉移語句return的兩種用法。
結合習題學習掌握典型問題的編程方法。