1.3 Java語言編程基礎

Java語言同樣遵循著嚴格的編程規范，Java的學習者必須了解Java語言的編程基礎，遵循其編程規范，才能編寫出好的Java程序。本節介紹的Java語法基礎主要有Java的基本數據類型、標識符與關鍵字、運算符、控制語句與異常處理等。

1.3.1 Java基本數據類型

Java是一種強類型語言，它有著非常豐富的數據類型，可分為原始數據類型（基本數據類型）和構造數據類型（引用數據類型）兩大類，其基本數據類型如表1.2所示。

說明：

Java語言的整型常量默認為int型，聲明long型常量必須加小寫“l”或大寫“L”。

Java浮點型常量默認為double型，聲明float型必須加小寫“f”或大寫“F”。

Java用Unicode碼來表示字符，Unicode碼定義了完全國際化的、可以表示所有人類語言已有的全部字符的字符集。

布爾型boolean主要用于邏輯測試。它只有兩種可能的取值：true或false。

構造數據類型（引用數據類型）主要有數組、類、對象、接口等。

1.3.2 Java標識符與關鍵字

1. Java標識符

在Java語言中，用來標識類名、對象名、變量名、方法名、類型名、數組名、文件名的有效字符序列被稱為“標識符”。簡單地說，標識符就是一個名字。

Java標識符命名規則如下。

（1）標識符由字母、下劃線“_”、美元符號“$”、數字組成。

（2）標識符由字母、下劃線“_”、美元符號“$”開頭。

（3）標識符大小寫敏感，長度無限制。

參照表1.3中的例子理解體會上述命名的規則。

2. Java關鍵字

關鍵字就是Java中賦以特定的含義，并用作專門用途的單詞，不能作為一般的標識符。程序員在編寫程序時，不能再使用這些詞匯來命名標識符，也不能改變這些詞匯的含義。這些專有詞匯，稱為“關鍵字”，如表1.4所示。注意所有Java關鍵字都是小寫英文。

說明：

數據和返回類型：int、void、return。

包/類/接口：package、class、interface。

修飾符：public、protected、private、final、abstract、static。

控制：continue、break、if、else、switch、case、default、do、for。

異常：try、catch、throw、throws、finally。

運算符：new、instanceof。

1.3.3 運算符

對于數據進行的操作稱為運算，表示各種不同運算的符號稱為運算符，參與運算的數據稱為操作數。表達式是由操作數和運算符按一定的語法形式組成的有意義的符號序列。對表達式中的操作數進行運算得到的結果稱為表達式的值，表達式值的數據類型即為表達式的類型。表達式的值還可以用作其他運算的操作數，形成更復雜的表達式。

Java語言中包括以下運算符。

單目算術運算符：+ +、- -、-。

雙目算術運算符：+、-、*、/、%。

賦值運算符：=、+=、-=、*=、/=、%=、&=、|=、>>=、>>>=、<<=、^=。

關系運算符：>、<、>=、<=、==、!= 。

邏輯運算符：&、&&、|、||、！、^。

位運算符：>>、<<、&、|、^、~。

條件運算符：？ ：。

成員運算符：. 。

下標運算符：[]。

實例類型判斷運算符：instanceof 。

創建對象運算符：new。

強制類型轉換運算符：（類型名稱）。

1. 單目算術運算符

單目運算符的操作數只有一個，算術運算符中有3個單目運算符，如表1.5所示。

表1.5　單目算術運算符

2. 雙目算術運算符

雙目算術運算符如表1.6所示。

3. 關系運算符

關系運算符是比較兩個數據的大小關系的運算符，關系運算符的結果是布爾型，即true或false，如表1.7所示。

4. 邏輯運算符

邏輯運算符是針對布爾型數據進行的運算，運算結果仍為布爾型量。常用的邏輯運算符如表1.8所示。

這里要特別對邏輯運算進行進一步說明：Java提供了兩個在其他大多數計算機語言中沒有的有趣的布爾運算符。這就是邏輯與和邏輯或這兩個運算符的特殊短路版本。例如，A && B、A || B。在邏輯或的運算中，如果第1個運算數A為真，則不管第2個運算數B是真是假，其運算結果都為真。同樣，在邏輯與的運算中，如果第1個運算數A為假，則不管第2個運算數是真是假，其運算結果都為假。如果運用||和&&的形式，而不是|和&，那么一個運算數就能決定表達式的值，Java的短路版本就不會對第2個運算數求值，只有在需要時才對第2個運算數求值。為了完成正確的功能，當右邊的運算數取決于左邊的運算數是真還是假時，短路版本是很有用的。例如，下面的程序語句說明了短路邏輯運算符的優點，用它來防止被0除的錯誤：

if (count != 0 && num / count > 10) 

既然用了短路與運算符，就不會有當count為0時產生的意外運行錯誤。如果該行代碼使用標準與運算符（&），則它將對兩個運算數都求值，當出現被0除的情況時，就會產生運行錯誤。

5. 位運算符

位運算指的是對操作數以二進制為單位進行的運算，運算結果為整數。也就是說，將操作數轉換為二進制表示形式，然后按位進行布爾運算，運算的結果也為二進制。位運算符及其運算規則如表1.9所示。

6. 賦值運算符

簡單賦值運算符形式為“=”，Java中還提供了復合賦值運算符，其形式為“運算符<op>=”。復合賦值運算符的含義如表1.10所示。

7. 條件運算符

Java中唯一的一個三元運算符是“?:”，它有3個操作數。這種語法的作用與雙分支的選擇語句很相似，但其返回值更直接，書寫形式更簡潔。其語法形式如下：

邏輯表達式？表達式1：表達式2 

其中，邏輯表達式為boolean類型表達式，先計算邏輯表達式的值，若為true，則整個三目運算的結果為表達式1的值，否則整個運算結果為表達式2的值。

8. 運算符優先級

當一個表達式中有多個運算符參與混合運算時，表達式的運算次序取決于表達式中各種運算符的優先級，也就是說，不同的運算符有不同的優先級。Java運算符優先級如表1.11所示。

1.3.4 程序控制語句

Java語言中的程序流程控制語句有3種：順序結構、選擇結構和循環結構。Java的每條語句一般以分號（“;”）作為結束標志。

順序結構：3種結構中最簡單的一種，即語句按照書寫的順序依次執行。

選擇結構：又稱分支結構，將根據布爾值來判斷應選擇執行哪一個流程分支。

循環結構：在一定條件下反復執行一段語句的流程結構。

1. If-else選擇語句

（1）簡單的if選擇語句

① if（條件表達式）。

語句              //只有一條語句 

② if（條件表達式）。

{ 
     一條或多條語句    //多條語句必須加大括號 
} 

（2）if-else雙分支選擇語句

① if（條件表達式）。

     語句1
else
     語句2

② if（條件表達式）。

{  
     語句塊1  
}
else
{  
     語句塊2  
}

（3）if-else-if多分支選擇語句

if（條件表達式1） 
{   語句塊1  } 
else  if（條件表達式2） 
{   語句塊2  } 
… 
else  if（條件表達式n-1） 
{   語句塊n-1  } 
else 
{    語句塊n   } 

2. switch語句

當選擇結構的分支越多時，if-else-if語句就會變得越來越難以看懂。Java提供了另一種多分支語句—switch語句。switch語句是多分支的開關語句。它的語法格式如下：

switch（表達式）{
     case 常量表達式1：語句組1；
                               [break;]
     case 常量表達式2：語句組2；
                               [break;]
     case 常量表達式3：語句組3；
                               [break;]
     …
     case 常量表達式n-1：語句組n-1；
                               [break;]
     default：語句塊n；
}

說明：

（1）switch后面的表達式的值的類型可以是char、byte、short、int型，但不能是boolean、long、float、double型。

（2）case后面的常量表達式的值的類型必須與switch后面的表達式的值的類型相匹配，而且必須是常量表達式或直接字面量。

（3）break語句可以省略，但省略時應注意，此時程序將按照順序逐個執行switch中的每一條語句，直到遇到右大括號或者break語句為止。

（4）語句塊可以是一條語句，也可以是多條語句，但此處的多條語句不需要使用大括號。

（5）case分支語句和default語句都不是必須的，也就是說它們在程序需要時是可以省略的。

3. while循環語句

while循環先判斷條件后做循環。while循環語句的語法格式如下：

while（布爾表達式）
{   語句塊 //循環體   }

說明：

（1）表達式必須是任何運算結果為布爾值的表達式。

（2）只有一條語句時可以省略大括號，但不建議這么做。

（3）while后面一定沒有分號，在大括號后面也沒有分號，這點初學者很容易忽略。

例1-1　使用while語句編寫程序，求1000以內的所有偶數的和（包含1000）。

public class TestWhile{
  public static void main(String[] args){
     int i = 1, sum=0;
     while(i <= 1000){
          if(i%2==0)
               sum = sum + i;
          i++;
     } 
     System.out.println("1000之內所有偶數的和是：" + sum);
  }
}

4. do-while循環語句

與while語句功能相似的另一個循環語句是do-while語句。先做循環后判斷條件。

do-while語句的語法格式如下：

do
{ 語句或語句塊 //循環體 }
while（布爾表達式）；

說明：

（1）表達式必須是任何計算結果為布爾值的表達式。

（2）只有一條語句時可以省略大括號，但不建議這么做。

（3）while后面一定要有分號，以表示do-while語句的結束。這一點與while語句不同。

例1-2　使用do-while語句編寫程序，求1000以內的所有偶數的和（包含1000）。

public class TestDoWhile{
  public static void main(String[] args){
     int i = 1, sum=0;                             
     do{
          if(i%2==0)                               //判斷i是否為偶數
               sum = sum + i;
          i++;
     } while(i <= 1000);
     System.out.println("1000之內所有偶數的和是：" + sum);
  }
}

5. for循環語句

在循環次數已知的情況下，可以使用for語句替代while或do-while語句。其語法格式如下：

for（初始化表達式；條件表達式；迭代式）
{  循環體語句  }

說明：

（1）初始化表達式通常用來對循環變量進行初始化，或者定義循環變量并初始化，在循環過程中只會被執行一次。

（2）條件表達式是一個布爾表達式，即運算結果為布爾值的表達式。只有當條件為true時才會執行。

（3）迭代表達式用于改變循環條件的語句，為繼續執行循環體語句做準備。

（4）初始化循環變量可以在for語句之前聲明，此時for語句中的初始化表達式就可以省略；循環變量的迭代式也可以在for循環體內執行，如for（；；）{…}。

例1-3　使用for循環語句，求1000以內的所有偶數的和（包含1000）。

public class TestFor{
  public static void main(String[] args){
     int  sum=0;                           
     for(int i = 1;i <=1000;i++){
            if(i%2==0)                             //判斷i是否為偶數
               sum = sum + i;
     } 
     System.out.println("1000之內所有偶數的和是：" + sum);
  }
}

6. 跳轉語句

（1）break語句在前面講過的switch語句、循環語句中，可以使用break語句來終止switch語句、循環語句的執行，而整個程序繼續執行后面的語句。

（2）continue語句：continue語句的作用是提前結束本次循環，立即開始下一輪循環。

continue語句與break語句的區別：continue語句只結束本次循環，并不終止整個循環的執行；而break語句則是結束整個循環過程，不再判斷循環的條件是否成立。

1.3.5 Java異常處理

異常是指程序在運行過程中出現由于硬件設備問題、軟件設計錯誤等導致的程序異常事件，Java異常是一個描述在代碼段中發生的異常情況的對象。

Java異常處理通過5個關鍵字控制：try、catch、throw、throws和finally。異常處理可以有以下幾種。

（1）對運行時異常不做處理，由系統尋找處理的代碼。

（2）使用try-catch-finally語句捕獲異常。

（3）通過throws子句聲明異常，還可自定義異常，用throw語句拋出。

1. try語句

為防止和處理一個運行時錯誤，只需要把你所要監控的代碼放進一個try塊就可以了。

例1-4　利用try語句捕獲異常。

try{
     int n;
     n = new classTest.method();
     int[] array = new int[10];
     for (int i=0; i<n ; i++){
        array[i] =i ;                                         //可能引起數組越界異常
      }
}

try語句可以被嵌套。一個try語句可以在另一個try塊內部。每次進入try語句，異常的前后關系都會入堆棧。如果一個內部的try語句不含特殊異常的catch處理程序，堆棧將彈出，下一個try語句的catch處理程序將檢查是否與之匹配。這個過程將繼續直到一個catch語句匹配成功，或者是直到所有的嵌套try語句被檢查耗盡。如果沒有catch語句匹配，Java運行時系統將處理這個異常。

2. catch語句

緊跟著try塊的，包括一個說明你希望捕獲的錯誤類型的catch子句。catch語句和try語句一起構成異常測試和捕獲處理代碼形式。

try-catch異常處理代碼塊的基本形式：
try{
          //監視可能發生異常的代碼塊
}
catch（異常類型異常對象名）  //捕獲并處理異常
{   
          //異常處理代碼塊
}

改寫上面的程序，包含一個因為被零除而產生的ArithmeticException異常的try塊和一個catch子句。

例1-5　利用try-catch語句捕獲ArithmeticException異常。

Public class Test
{ 
        public static void main(String args[]) 
        { 
               int a, b; 
               try 
               { 
                    a = 0; 
                    b= 5 / a; 
                    System.out.println("This will not be printed."); 
               } 
               catch (ArithmeticException e) 
               { 
                       System.out.println("Division by zero."); 
               } 
         System.out.println("After catch statement."); 
     } 
} 

該程序輸出如下：

Division by zero. 
After catch statement. 

某些情況，由單個代碼段可能引起多個異常。處理這種情況，可以定義兩個或更多的catch子句，每個子句捕獲一種類型的異常。當異常被引發時，每一個catch子句被依次檢查，第一個匹配異常類型的子句被執行。當一個catch語句執行以后，其他的子句被旁路，執行從try-catch塊以后的代碼開始繼續。多個catch異常處理代碼塊的基本形式：

try{
     //可能發生異常的代碼塊
}catch（異常類型1異常對象名1）{
     //異常處理代碼塊1
}
…
catch（異常類型n異常對象名n）{
     //異常處理代碼塊n；
}

3. finally語句

finally關鍵字是Java異常處理的最后一個語句，無論try語句中是否出現異常、出現哪種類型異常，finally關鍵字中包含的語句都必須被執行。如果異常被引發，finally甚至是在沒有與該異常相匹配的catch子句的情況下也將執行。finally子句是可選項，可以有也可以無。然而每一個try語句至少需要一個catch或finally子句。

下面的例子顯示了3種不同的退出方法，每一個都執行了finally子句。

例1-6　利用try-finally捕獲異常。

class FinallyDemoTest 
{ 
       static void procA() 
     { 
     try 
     { 
     System.out.println("inside procA"); 
     throw new RuntimeException("demo"); 
     } 
     finally 
     { 
     System.out.println("procA's finally"); 
          } 
     } 
     static void procB() 
     { 
     try 
     { 
               System.out.println("inside procB"); 
               return; 
     } 
     finally 
     { 
               System.out.println("procB's finally"); 
     } 
} 
static void procC() 
{ 
     try 
     { 
          System.out.println("inside procC"); 
     } 
     finally 
     { 
          System.out.println("procC's finally"); 
     } 
    }
public static void main(String args[]) 
{ 
     try 
     { 
          procA(); 
     } 
     catch (Exception e) 
     { 
          System.out.println("Exception caught"); 
          } 
          procB(); 
          procC(); 
     } 
} 

procA()中finally子句在退出時執行。procB()中返回之前finally子句執行。procC()中沒有錯誤，但finally塊仍將執行。

下面是上述程序的輸出結果：

inside procA 
procA's finally 
Exception caught 
inside procB 
procB's finally 
inside procC 
procC's finally