第2章　Java開發基礎——Java語言入門

◎　本章教學微視頻：27個　135分鐘

學習指引

學習一種編程語言，第一步是要學習它的開發基礎，Java語言也不例外。本章就來介紹Java編程語言的開發基礎，主要內容包括Java的數據類型、常量與變量、賦值、數據類型、運算符等。

重點導讀

• 熟悉Java語言的基礎語法。
• 掌握Java語言的數據類型。
• 掌握數據類型轉換的方法。
• 掌握Java語言的常量與變量。
• 掌握Java運算符的使用方法。

2.1　剖析第一個Java程序

通過第1章的學習，相信讀者已經能夠使用Eclipse編寫出第一個Java程序“Hello World!”。完整代碼如下：

【例2-1】（實例文件：ch02\Chap2.1.txt）使用Eclipse編寫第一個Java程序“Hello World!”。

     public class Test {
         public static void main(String[] args) {
             System.out.println("Hello World!");
         }
     }

運行結果如圖2-1所示。

圖2-1　“Hello World!”程序的運行結果

下面通過剖析這個程序，讓讀者對Java程序有更進一步的認識。所有的Java程序都必須放在一個類之中才可以執行，定義類的語法形式如下：

     [public] class 類名稱{
     }

類定義有兩種形式，分別如下：

• public class：文件名稱必須與類名稱保持一致，每一個*.java文件中只能夠定義一個public class。
• class：文件名稱可以和類名稱不一致，在一個*.java文件中可以同時定義多個class，并且編譯之后會發現不同的類都會保存在不同的*.class文件中。

此處有一個重要的命名約定需要遵守：在定義類名稱的時候，每個單詞的首字母都必須大寫，例如TestJava、HelloDemo。

主方法（main）是一切程序的開始點，主方法的編寫形式如下（一定要在類中寫）：

     public static void main(String[] args) {
           編寫代碼語句;
     }

這是一個主方法（main），它是整個Java程序的入口，所有的程序都是從public static void main（String[]args）開始運行的，這一行的代碼格式是固定的。括號內的String[] args不能省掉，如果不寫，會導致程序無法執行。String[] args也可以寫成String args[]，String表示參數args的數據類型為字符串類型，[]表示它是一個數組。

main之前的public static void都是Java的關鍵字，public表示該方法是公有類型，static表示該方法是靜態方法，void表示該方法沒有返回值。這些關鍵字如果現在還不太明白，可以暫時不用深究，現在了解一下即可，在之后的章節中會有更加詳細的介紹。

當需要在屏幕上顯示數據的時候，就可以使用如下的方法完成：

• 輸出之后增加換行：System.out.println（輸出內容）。
• 輸出之后不增加換行：System.out.print（輸出內容）。

【例2-2】（實例文件：ch02\Chap2.2.txt）print與println的區別，觀察換行的情況。

     public class Test {
         public static void main(String[] args) {
             System.out.print("Hello") ;
             System.out.print(" World ") ;
             System.out.println(" !!! ") ;
             System.out.println("你好世界！") ;
         }
     }

程序運行結果如圖2-2所示。

圖2-2　print與println的區別

通過運行結果可以看出，雖然Hello、World和!!!分為3個語句輸出，但顯示結果還是在一行，說明print在輸出之后沒有換行，而println在輸出之后增加了換行。

2.2　Java基礎語法

一個Java程序可以認為是一系列對象的集合，而這些對象通過調用彼此的方法來協同工作。其中，對象是類的一個實例，有狀態和行為；類是一個模板，用于描述一類對象的行為和狀態；方法是行為，一個類可以有很多方法，例如邏輯運算、數據修改以及所有動作都是在方法中完成的。

2.2.1　基本語法

編寫Java程序時，應注意以下幾點：

• Java是大小寫敏感的，這就意味著標識符Hello與hello是不同的。
• 對于所有的類來說，類名的首字母都應該大寫。如果類名由若干單詞組成，那么每個單詞的首字母應該大寫，例如MyFirstJavaClass。
• 所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則后面的每個單詞首字母大寫。
• 源文件名必須和類名相同。當保存文件的時候，應該使用類名作為文件名保存（切記Java是大小寫敏感的），文件名的后綴為.java。如果文件名和類名不相同則會導致編譯錯誤。
• 所有的Java程序都由public static void main（String []args）方法開始執行。

2.2.2　Java標識符

Java所有的組成部分都需要名字。類名、變量名以及方法名都被稱為標識符。例如，在前面定義的Hello這個類的名稱就是一種標識符。在Java中，標識符可以使用字母、數字、_、$進行定義，不能以數字開頭，不能是Java的關鍵字或保留字。

定義的標識符要有意義，例如studentName、School等，這些都是有意義的詞。特別要注意的是，標識符不能使用Java的關鍵字，關鍵字指的是一些語法結構部分之中有特殊含義的標記。例如，在圖2-3中，代碼行中用下畫線標記的單詞都是關鍵字（在屏幕上這些關鍵字顯示為紅色），都不能夠作為標識符。

圖2-3　關鍵字和標識符

例如，下面的標識符是合法的：myName1、My_name1、Points1、$points、_my_name、PI、_50c；而下面的標識符是非法的：20name、#name、class、&time、if。

總之，在Java中，標識符的命名有一些規則，這些規則是大家約定俗成的，應該遵守。

• 類和接口名每個單詞的首字母大寫，例如，MyClass，HelloWorld，Time等。
• 方法名首個單詞的首字母小寫，其余單詞的首字母大寫，盡量少用下畫線，例如myName、setTime等。這種命名方法叫作駝峰式命名。
• 基本數據類型的常量名全部使用大寫字母，單詞之間用下畫線分隔，例如SIZE_NAME。對象常量可大小混寫。
• 變量名可大小寫混寫，首字母小寫，單詞間起分隔或連接作用的詞（如To、Of）首字母大寫。不用下畫線，少用美元符號。給變量命名時盡量做到見名知義。

另外，關于Java標識符，還需要注意以下幾點：

• 所有的標識符都應該以字母（A～Z或者a～z）、美元符（$）或者下畫線（_）開始。
• 首字符之后可以是字母（A～Z或者a～z）、美元符（$）、下畫線（_）或數字的任何字符組合。
• 關鍵字不能用作標識符。
• 標識符是大小寫敏感的，應區分字母的大小寫。

2.2.3　Java關鍵字

表2-1列出了Java的關鍵字，這些關鍵字不能用于常量、變量以及任何標識符的名稱。

表2-1　Java的關鍵字

以上的所有關鍵字都不需要專門地去記，隨著代碼寫熟了，自然就記住了。但是針對以上的關鍵字，還有幾點說明：

• Java的關鍵字是隨新的版本發布而不斷變動的，不是一成不變的。
• 所有關鍵字都是小寫的。
• goto和const不是Java編程語言中使用的關鍵字，它們是Java的保留字，也就是說Java保留了它們，但是沒有使用它們。
• 有3個標識符嚴格來講不是關鍵字，可是具備特殊含義：true（真）、false（假）、null（空）。
• 表示類的關鍵字是class。

2.2.4　Java保留字

Java保留字是為Java預留的關鍵字，現在還沒用到，但是在升級版本中可能作為關鍵字使用。Java中的保留字為const和goto。

2.2.5　Java分隔符

在Java中，有一類特殊的符號稱為分隔符，包括空白分隔符和普通分隔符。空白分隔符包括空格、回車、換行和制表符（Tab鍵）。空白分隔符的主要作用是分隔標識符，幫助Java編譯器理解源程序。例如：

     int a;

若標識符int和a之間沒有空格，即inta，則編譯程序會認為這是用戶定義的標識符，但實際上該語句的作用是定義變量a為整型變量。

另外，在編寫代碼時，適當的空格和縮進可以增強代碼的可讀性，例如下面這段代碼：

     public class HelloWorld {
         public static void main(String[] args) {
             System.out.println("Hello World!");
         }
     }

在這個程序中，用到了大量的用于表示代碼語句層次的空白分隔符（主要是制表符和回車），如果不使用這些空白分隔符，這個程序可能會顯示如下：

     public class HelloWorld{public static void main(String[] args){
     System.out.println("Hello World!");}
     }

與上一個程序相比，這個程序沒有使用制表符來做縮排，轉行也減少了，顯然在層次感上差了很多。甚至還可能是如下情況：

     public class HelloWorld{public static void main(String[] args){System.out.println("Hello World!");}}

這個程序將所有的語句都寫在同一行上。在語法上，這個程序是正確的，但是在可讀性上是非常不好的。因此，在寫程序的時候要靈活地使用空白分隔符來分隔語句或者做格式上的縮排。但是，空白分隔符也不能濫用。使用空白分隔符要遵守以下規則：

• 任意兩個相鄰的標識符之間至少有一個空白分隔符，以便編譯程序能夠識別。
• 變量名、方法名等標識符不能包含空白分隔符。
• 空白分隔符的多少沒有什么含義，一個空白分隔符和多個空白分隔符的作用相同，都是用來實現分隔功能的。
• 空白分隔符不能用普通分隔符替換。

普通分隔符具有確定的語法含義，如表2-2所示。

表2-2　Java的普通分隔符

Eclipse提供了一種簡單快速調整程序格式的功能，可以選擇Source→Format菜單命令來調整程序格式，如果程序沒有錯誤的話，格式會變成預定義的樣式。在程序編寫完成后，執行快速格式化，可以使代碼美觀整齊，應該養成這個習慣。

2.2.6　Java注釋

類似于C/C++，Java也支持單行以及多行注釋。注釋中的字符將被Java編譯器忽略。例如，如下一段代碼里面具有單行注釋與多行注釋：

     public class HelloWorld {
        /* 這是第一個Java程序
         * 它將打印Hello World
         * 這是一個多行注釋的實例
         */
         public static void main(String []args){
            //這是單行注釋的實例
            /* 這也是單行注釋的實例 */
            System.out.println("Hello World");
         }
     }

在給代碼添加注釋時，程序員需要注意注釋的規范，下面介紹幾種注釋規范。

1．類注釋

在每個類前面必須加上類注釋，注釋模板如下：

     /**
      * Copyright (C), 2006-2010, ChengDu Lovo info. Co., Ltd.
      * FileName: Test.java
     * 類的詳細說明
     *
     * @author       類創建者姓名
     * @Date         創建日期
     * @version 1.00
     */

2．屬性注釋

在每個屬性前面必須加上屬性注釋，注釋模板如下：

     /** 提示信息 */
     private String strMsg = null;

3．方法注釋

在每個方法前面必須加上方法注釋，注釋模板如下：

     /**
      * 類方法的詳細使用說明
      *
      * @param 參數1 參數1的使用說明
      * @return 返回結果的說明
      * @throws 異常類型.錯誤代碼 注明從此類方法中拋出異常的說明
      */

4．構造方法注釋

在每個構造方法前面必須加上注釋，注釋模板如下：

     /**
      * 構造方法的詳細使用說明
      *
      * @param 參數1 參數1的使用說明
      * @throws 異常類型.錯誤代碼 注明從此類方法中拋出異常的說明
      */

5．方法內部注釋

在方法內部使用單行或者多行注釋，該注釋根據實際情況添加。例如：

     //背景顏色
     Color bgColor = Color.RED

2.3　數據類型

程序實際上指的就是針對數據的處理流程，那么程序所能夠處理的數據的劃分就是各個語言的數據類型，在Java中，數據類型分為兩大類：基本數據類型和引用數據類型。Java數據類型的劃分如圖2-4所示。

圖2-4　Java數據類型的劃分

Java數據類型的默認值如表2-3所示。

表2-3　Java數據類型的默認值

各數據類型的數據范圍和占據的內存空間如表2-4所示。

表2-4　數據類型的數據范圍和占據的內存空間

下面詳細介紹Java的4大類（整型、浮點型、字符型、布爾型）8種基本數據類型以及字符串（String）。

2.3.1　整型

整數類型簡稱整型，表示的是不帶小數點的數字，例如，數字5、100就是整型數據。在Java中，有4種不同類型的整型，分別為byte、short、int和long。默認情況下一個整數的對應類型就是int類型。

每一種數據類型都有其對應數據范圍的最大或最小值，如果在計算的過程中超過了此范圍，就會產生數據的溢出問題。而要想解決數據的溢出問題，最好的做法是擴大數據范圍，例如可以將int類型轉換為long類型，轉換方法有兩種，直接在數據前增加一個“（long）”或者直接在數據后增加一個字母L（大小寫均可）。

在Java中，byte類型的數據占據8位內存空間，數值取值范圍是-128～127。

【例2-3】（實例文件：ch02\Chap2.3.txt）輸出byte類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             byte byte_min = Byte.MIN_VALUE;              //獲得byte類型的最小值
             byte byte_max = Byte.MAX_VALUE;              //獲得byte類型的最大值
             System.out.println("byte類型的最小值是："+byte_min);
             System.out.println("byte類型的最大值是："+byte_max);
         }
     }

程序運行結果如圖2-5所示。

圖2-5　byte類型的最小值與最大值

short類型數據占據16位內存空間，取值范圍是-32768～32767。

【例2-4】（實例文件：ch02\Chap2.4.txt）輸出short類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             short short_min = Short.MIN_VALUE;                //獲得short類型的最小值
             short short_max = Short.MAX_VALUE;                //獲得short類型的最大值
             System.out.println("short類型的最小值是："+short_min);
             System.out.println("short類型的最大值是："+short_max);
         }
     }

程序運行結果如圖2-6所示。

圖2-6　short類型的最小值與最大值

int類型的數據占據32位內存空間，取值范圍是-2 147 483 648～2 147 483 647。

【例2-5】（實例文件：ch02\Chap2.5.txt）輸出int類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             int int_min = Integer.MIN_VALUE;             //獲得int類型的最小值
             int int_max = Integer.MAX_VALUE;             //獲得int類型的最大值
             System.out.println("int類型的最小值是："+int_min);
             System.out.println("int類型的最大值是："+int_max);
         }
     }

程序運行結果如圖2-7所示。

圖2-7　int類型的最小值與最大值

long類型的數據占據64位內存空間，取值范圍是-9 223 372 036 854 775 808～9 223 372 036 854 775 807。

【例2-6】（實例文件：ch02\Chap2.6.txt）輸出long類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             long long_min = Long.MIN_VALUE;         //獲得long類型的最小值
             long long_max = Long.MAX_VALUE;         //獲得long類型的最大值
             System.out.println("long類型的最小值是："+long_min);
             System.out.println("long類型的最大值是："+long_max);
         }
     }

程序運行結果如圖2-8所示。

圖2-8　long類型的最小值與最大值

2.3.2　浮點型

Java浮點數據類型主要有雙精度（double）和單精度（float）兩個類型。在Java中，一個小數默認的類型是double，而double類型的范圍是最大的。如果定義小數為float類型，為其賦值的時候，必須執行強制轉型。有兩種轉換方式：一種是直接加上字母F（大小寫均可），例如“float num = 2.8F ;”；另一種是直接強制轉型為float，例如“float num2 = (float) 10.5 ;”。

【例2-7】（實例文件：ch02\Chap2.7.txt）輸出float類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             float float_min = Float.MIN_VALUE;           //獲得float類型的最小值
             float float_max = Float.MAX_VALUE;           //獲得float類型的最大值
             System.out.println("float類型的最小值是："+float_min);
         System.out.println("float類型的最大值是："+float_max);
        }
     }

程序運行結果如圖2-9所示。

圖2-9　float類型的最小值與最大值

【例2-8】（實例文件：ch02\Chap2.8.txt）輸出double類型的最小值與最大值。

     public class Test {
         public static void main(String[] args) {
             double double_min = Double.MIN_VALUE;             //獲得double類型的最小值
             double double_max = Double.MAX_VALUE;             //獲得double類型的最大值
             System.out.println("double類型的最小值是："+double_min);
             System.out.println("double類型的最大值是："+double_max);
         }
     }

程序運行結果如圖2-10所示。

圖2-10　double類型的最小值與最大值

2.3.3　字符型

Java中默認采用的編碼方式為UNICODE編碼，它是一種十六進制編碼方案，可以表示世界上的任意文字信息。所以在Java中字符里面是可以保存中文數據的。在程序中使用單引號‘’聲明的數據就稱為字符型數據，字符型用char表示，占16位內存空間。

在ASCII碼表中，大寫字母的ASCII碼值范圍是65～90，小寫字母的ASCII碼值范圍是97～122，可以發現，對應的大寫字母和小寫字母ASCII碼值的差是32，按照此規律，就可以輕松實現大小寫的轉換操作。

【例2-9】（實例文件：ch02\Chap2.9.txt）輸出字母a的ASCII碼值，并將字母a轉換為大寫。

     public class Test {
         public static void main(String[] args) {
            char x = 'a';
            int y = x;                         //將字符型賦值給整型
            System.out.println(y);             //輸出字母a的ASCII碼值97

            //將字母a轉換為A，在ASCII碼中值相差32，(char)表示將int類型強制轉換為char類型
            System.out.println((char)(y-32));
         }
     }

程序運行結果如圖2-11所示。

圖2-11　例2-9的運行結果

2.3.4　布爾型

布爾是一位數學家的名字。布爾型在Java中使用boolean聲明，而布爾值的取值只有兩個：true、false，一般而言，布爾型數據往往都用于條件判斷。但是在這里必須重點強調的是：在一些語言中，例如C語言，把0當作false，而把非0值當作true，可是在Java中，布爾值只有true和false，沒有0或者非0值。

【例2-10】（實例文件：ch02\Chap2.10.txt）輸出Boolean類型數據。

     public class Test {
         public static void main(String[] args) {
             boolean t = true;
             System.out.println("t="+t);
         }
     }

程序運行結果如圖2-12所示。

圖2-12　Boolean類型數據

2.3.5　字符串

字符型只能夠包含單個字符，這在很多情況下是無法滿足要求的，所以在Java中專門提供了String（字符串）類型。String是引用型數據，是一個類（因此String的首字母一定要大寫），但是這個類稍微特殊一些。

對String類型的變量使用“+”，則表示要執行字符串的連接操作。但“+”既可以表示數據的加法操作，也可以表示字符串連接，那么如果這兩種操作碰到一起了那么會怎么樣呢？如果遇到了字符串，所有其他的數據類型（基本、引用）都會自動變為String型數據。

【例2-11】（實例文件：ch02\Chap2.11.txt）輸出字符串類型。

     public class Test {
         public static void main(String[] args) {
             String s1 = "我愛學";
             String s2 = "Java!";
             System.out.println(s1+s2);        //此處的加號表示連接
         }
     }

程序運行結果如圖2-13所示。

圖2-13　字符串類型

2.4　數據類型的轉換

Java語言是一種強類型的語言。強類型的語言有以下幾個要求：

• 變量或常量必須有類型：要求聲明變量或常量時必須聲明類型，而且只能在聲明以后才能使用。
• 賦值時，值的類型必須和變量或常量的類型一致。
• 運算時，參與運算的數據類型必須一致。

但是在實際的使用中，經常需要在不同類型的值之間進行操作，這就需要一種新的語法來適應這種需要，這個語法就是數據類型轉換。

在數值處理上，計算機和現實的邏輯不太一樣。對于現實來說，1和1.0沒有什么區別；但是對于計算機來說，1是整數類型，而1.0是小數類型，其在內存中的存儲方式以及占用的空間都不一樣，所以類型轉換在計算機內部是必須明確地進行的。

Java語言中的數據類型轉換有兩種：

• 自動類型轉換：編譯器自動完成類型轉換，不需要在程序中編寫代碼。
• 強制類型轉換：強制編譯器進行類型轉換，必須在程序中編寫代碼。

由于基本數據類型中boolean類型不是數字型，所以基本數據類型的轉換是除了boolean類型以外的其他7種類型之間的轉換。下面來具體介紹兩種類型轉換的規則、適用場合以及使用時需要注意的問題。

2.4.1　自動類型轉換

自動類型轉換，也稱隱式類型轉換，是指不需要書寫代碼，由系統自動完成類型轉換。由于實際開發中這樣的類型轉換很多，所以Java語言在設計時沒有為該操作設計語法，而是由JVM自動完成。

有3種可以進行自動類型轉換的情況，具體如下：

（1）整數類型之間可以實現轉換，如byte類型的數據可以賦值給short、int、long類型的變量，short、char類型的數據可以賦值給int、long類型的變量，int類型的數據可以賦值給long類型的變量。

（2）整數類型轉換為float類型，如byte、char、short、int類型的數據可以賦值給float類型的變量。

（3）其他類型轉換為double類型，如byte、char、short、int、long、float類型的數據可以賦值給double類型的變量。

在具體轉換的過程中，應遵循相應的轉換規則，這里的規則為只能從存儲范圍小的類型轉換到存儲范圍大的類型。具體規則為byte→short(char)→int→long→float→double。

也就是說byte類型的變量可以自動轉換為short類型，例如：

     byte  b=10;
     short  sh=b;

這里在賦值時，JVM首先將b的值轉換為short類型，然后再賦值給sh。

另外，在類型轉換時可以跳躍。例如：

     byte  b1=100;
     int  n=b1;

注意：在整數之間進行類型轉換時，數值不發生改變，而將整數類型，特別是比較大的整數類型轉換成小數類型時，由于存儲方式不同，有可能存在數據精度的損失。

【例2-12】（實例文件：ch02\Chap2.12.txt）將int類型轉換為float類型，并輸出兩個數據之和。

     public class Test {
         public static void main(String[] args) {
             int x = 10;
             float y = 20.3f;
             System.out.println(x + y);            //int類型的x會自動轉換為float類型
         }
     }

程序運行結果如圖2-14所示。

圖2-14　轉換數據類型

2.4.2　強制類型轉換

強制類型轉換，也稱顯式類型轉換，是指必須書寫代碼才能完成的類型轉換。強制類型轉換很可能存在精度的損失，所以必須書寫相應的代碼，并且能夠接受精度損失時才進行強制類型轉換。

強制類型轉換的規則為從存儲范圍大的類型轉換到存儲范圍小的類型。具體規則為：double→float→long→int→short(char)→byte。具體的語法格式為（轉換到的類型）需要轉換的值。

實例代碼如下：

     double  d  =  3.10;
     int  n  =  (int)d;

這里將double類型的變量d強制轉換成int類型，然后賦值給變量n。需要說明的是，小數強制轉換為整數，采用的是“去1法”，也就是無條件舍棄小數點后的所有數字，因此以上轉換的結果是3。int類型的變量轉換為byte類型時，則只保留int類型的低8位（也就是最后一個字節）的值。例如：

     int  n  =  123;
     byte  b  =  (byte)n;
     int  m  =  1234;
     byte  b1  =  (byte)m;

則b的值還是123，而b1的值為-46。b1的計算方法為：m的值轉換為二進制是10011010010，取該數字低8位的值作為b1的值，則b1的二進制值是11010010，按照機器數的規定，最高位是符號位，1代表負數，在計算機中負數存儲的是補碼，則該負數的原碼是10101110，該值就是十進制的-46。

注意：強制類型轉換通常都會有精度的損失，所以使用時需要謹慎。

【例2-13】（實例文件：ch02\Chap2.13.txt）將float類型強制轉換為int類型，并輸出兩數之和。

     public class Test {
         public static void main(String[] args) {
             int x = 10;
             float y = 20.3f;
             //x+y的結果是float類型，(int)表示強制轉換為int類型
             System.out.println((int) (x + y));
        }
     }

程序運行結果如圖2-15所示。

圖2-15　將float類型強制轉換為int類型

2.5　常量與變量

有些數據在程序運行過程中值不能發生改變，有些數據在程序運行過程中值會發生改變，這兩種數據在程序中分別被叫作常量和變量。

在實際的程序開發中，可以根據數據在程序運行中是否發生改變來選擇應該是使用變量還是常量代表它。

2.5.1　常量

常量就是固定不變的量，一旦被定義，它的值就不能再被改變。聲明常量的語法為

     final 數據類型 常量名稱 [ = 值 ]

常量名稱通常使用大寫字母，例如PI、YEAR等，但這并不是硬性要求，而只是一個習慣。常量標識符可由任意順序的大小寫字母、數字、下畫線（_）和美元符號（$）等組成，不能以數字開頭，也不能是Java中的保留字和關鍵字。

當常量用于一個類的成員變量時，必須給常量賦值，否則會出現編譯錯誤。下面是一個常量的應用實例。

【例2-14】（實例文件：ch02\Chap2.14.txt）輸出圓周率PI的數值。

     public class Test {
         public static void main(String[] args) {
             final double PI=3.14159265;
             System.out.println("圓周率π約等于"+PI);
         }
     }

程序運行結果如圖2-16所示。

圖2-16　輸出圓周率PI

注意：Java中的關鍵字const是保留字，目前并沒被Java正式啟用，因此不能像C++語言那樣使用const來定義常量。

2.5.2　變量

變量代表程序的狀態，程序通過改變變量的值來改變整個程序的狀態。為了方便引用變量的值，在程序中需要為變量設定一個名稱，這就是變量名。例如在3D游戲程序中，人物的位置需要3個變量，分別是x坐標、y坐標和z坐標。在程序運行過程中，這3個變量的值會發生改變。

由于Java語言是一種強類型的語言，所以變量在使用以前必須首先聲明數據類型，在程序中聲明變量的語法格式如下：

     數據類型 變量名稱；

例如：

     int a；

在該語法格式中，數據類型可以是Java語言中任意的類型，包括前面介紹的基本數據類型以及后續將要介紹的復合數據類型。變量名稱是該變量的標識符，需要符合標識符的命名規則，在實際使用中，該名稱一般和變量的用途對應，這樣便于程序的閱讀。數據類型和變量名稱之間使用空格進行間隔，空格的個數不限，但是至少需要一個。語句使用“；”作為結束。也可以在聲明變量的同時設定該變量的值，語法格式如下：

     數據類型 變量名稱 = 值；

例如：

     int a = 100；

在該語法格式中，=代表賦值，“值”代表具體的數據。注意區別=和==，“==”用于判斷是否相等。在該語法格式中，要求值的類型需要和聲明變量的數據類型一致。

在程序中，變量的值代表程序的狀態，在程序中可以通過變量名稱來引用變量的值，也可以為變量重新賦值。例如：

     int m = 15；
     m = 100；

在實際開發過程中，需要聲明什么類型的變量，需要聲明多少個變量，需要為變量賦什么數值，都根據程序邏輯決定，上面的例子只是為了說明用法。

【例2-15】（實例文件：ch02\Chap2.15.txt）輸出變量x的數值。

     public class Test {
         public static void main(String[] args) {
             int x = 10;             //聲明變量x為int類型，并賦值為10
             x = 20;                 //改變變量x的值為20
             System.out.println("x="+x);
         }
     }

程序運行結果如圖2-17所示。

圖2-17　輸出變量x的數值

2.5.3　變量的作用域

在Java中，變量的作用域分為4個級別：類級、對象實例級、方法級、塊級。類級變量又稱全局變量或靜態變量，需要使用static關鍵字修飾。類級變量在類定義后就已經存在，占用內存空間，可以通過類名來訪問，不需要實例化。對象實例級變量就是成員變量，實例化后才會分配內存空間，也才能訪問。方法級變量就是在方法內部定義的變量，又稱局部變量。

在定義變量時，還需要注意以下幾點：

• 方法內部除了能訪問方法級變量，還可以訪問類級和對象實例級變量。
• 塊內部能夠訪問類級、對象實例級變量。如果塊被包含在方法內部，它還可以訪問方法級變量。
• 方法級和塊級變量必須顯式地初始化，否則不能訪問。

【例2-16】（實例文件：ch02\Chap2.16.txt）變量作用域應用實例。

程序運行結果如圖2-18所示。

圖2-18　變量作用域

通過這個例子可以看出，變量在不同的地方起作用的范圍也是不同的。塊中定義的變量是局部變量，不能被外部調用。

2.6　Java的運算符

計算機程序是由許多語句組成的，而語句是由更基本的表達式和運算符組成的。計算機最基本的用途之一就是執行數學運算，作為一門計算機語言，Java也提供了一套豐富的運算符來操縱變量。可以把運算符分成以下幾種：

• 算術運算符。
• 自增自減運算符。
• 關系運算符。
• 邏輯運算符。
• 賦值運算符。
• 條件運算符。
• 位運算符。

下面分別介紹各種運算符的使用。

2.6.1　算術運算符

算術運算符用在數學表達式中，它們的作用和在數學中的作用基本一樣。算術運算符的含義及應用實例如表2-5所示。表格中的實例假設整數變量A的值為10，變量B的值為20。

表2-5　算術運算符的含義及應用實例

【例2-17】（實例文件：ch02\Chap2.17.txt）下面的簡單實例程序演示了算術運算符的用法。

程序運行結果如圖2-19所示。

圖2-19　算術運算符

2.6.2　自增自減運算符

自增（++）和自減（--）是兩個特殊的算術運算符，大多數算術運算符需要兩個操作數來進行運算，而自增自減運算符只需要一個操作數。自增自減運算符的含義及應用實例如表2-6所示。表格中的實例假設整數變量A的值為10，變量B的值為20。

表2-6　自增自減運算符的含義及應用實例

【例2-18】（實例文件：ch02\Chap2.18.txt）自增運算++a應用實例。

     public class Test {
         public static void main(String[] args) {
             int a = 10;
             int b = 20;
             b = ++a;
             System.out.println("a=" +a+ ",b="+b);
         }
     }

程序運行結果如圖2-20所示。通過結果可以看到，b=++a是a先加1，然后把結果賦予b。

圖2-20　自增運算++a

【例2-19】（實例文件：ch02\Chap2.19.txt）自增運算a++應用實例。

     public class Test {
         public static void main(String[] args) {
             int a = 10;
             int b = 20;
             b = a++;
             System.out.println("a="+a+", b="+b);
        }
     }

程序運行結果如圖2-21所示。通過結果可以看到，b=a++是先將a的值賦予b，然后a再加1。

圖2-21　自增運算a++

總之，b=a++或者b=++a，對a來說最后的結果都是自加1，但對b來說結果就不一樣了。通過這兩個例子，希望讀者能夠明白a++和++a的區別。a--和--a的情況與此類似。

2.6.3　關系運算符

關系運算符也稱為比較運算符，用于對兩個操作數進行關系運算，以確定兩個操作數之間的關系。常用的關系運算符的含義及應用實例如表2-7所示。表中的實例假設整數變量A的值為10，變量B的值為20。

表2-7　關系運算符的含義及應用實例

【例2-20】（實例文件：ch02\Chap2.20.txt）輸出兩個數的比較結果。

     public class Test {
         public static void main(String[] args) {
             int a = 10, b = 20;
             if (a > b) {
                 System.out.println("a>b");
             }
             if (a < b) {
                 System.out.println("a<b");
             }
             if (a == b) {
                 System.out.println("a=b");
             }
         }
     }

程序運行結果如圖2-22所示。在上述程序中，首先定義了a和b的數據類型為int類型，并進行了賦值。通過if語句判斷a和b的大小關系，一共有3種關系——大于、小于或等于，并將結果顯示出來。因為a=10，b=20，因此最后結果是a<b。

圖2-22　關系運算符實例

注意：如果要判斷兩個變量是否相等，不是使用=，而是使用==。=表示賦值，==表示判斷，這是一個非常容易出錯的地方，讀者應該特別注意。

2.6.4　邏輯運算符

邏輯運算符主要用來把各個運算的變量連接起來，組成一個邏輯表達式，以判斷某個表達式是否成立，判斷的結果是true或false。邏輯運算符的含義及應用實例如表2-8所示。表中的實例假設布爾變量A為真，B為假。

表2-8　邏輯運算符的含義及應用實例

【例2-21】（實例文件：ch02\Chap2.21.txt）邏輯運算符！應用實例。

     public class Test {
         public static void main(String[] args) {
             boolean flag = true;
             System.out.println(!flag);
         }
     }

程序運行結果如圖2-23所示。上述代碼中，首先定義flag為布爾型，并賦值為true，通過邏輯非運算符將flag的值改變為false。

圖2-23　邏輯非運算符實例

邏輯運算符的重點是與和或兩種運算，它們各有兩組不同的實現。與操作的特點是若干個條件都要同時滿足，若有一個條件不滿足，則最終的結果就是false。在Java中與操作分為兩種不同的形式——&和&&，下面舉例說明。

【例2-22】（實例文件：ch02\Chap2.22.txt）&應用實例。

     public class Test {
         public static void main(String[] args) {
             if (1 == 2 & 1 / 0 == 0) {//false & 錯誤
                 System.out.println("條件滿足！") ;
             }
         }
     }

程序運行結果如圖2-24所示。運行后發現代碼出現了錯誤，提示除數為0。這說明1==2和1/0==0這兩個條件都進行了判斷，即使第一個條件1==2已經不成立，也會繼續判斷第二個條件是否成立。但這是沒有必要的，因為只要有一個條件是false，那么即使后面的條件都成立，最終結果也是false。

圖2-24　&應用實例

上述實例說明&會將所有的判斷條件都加以驗證。下面使用與運算的另外一種形式——&&。

【例2-23】（實例文件：ch02\Chap2.23.txt）&&應用實例。

     public class Test {
         public static void main(String[] args) {
             if (1 == 2 && 1 / 0 == 0) {
                 System.out.println("條件滿足！") ;
             }
         }
     }

程序運行結果如圖2-25所示。在上述代碼中，與運算符為&&，運行結果沒有出錯，但也沒有任何顯示。這說明在判斷完1==2條件為false后，就終止了后面的判斷，if的條件表達式的最終結果為false。這說明&&只要判斷某個條件為false，不管后面有多少個條件都不再進行判斷，最終結果就是false。

圖2-25　&&應用實例

或運算的若干個條件有一個滿足即可，或運算符兩種：|和||。

【例2-24】（實例文件：ch02\Chap2.24.txt）|應用實例。

     public class Test {
         public static void main(String[] args) {
             if (1 == 1 | 1 / 0 == 0) {
                 System.out.println("條件滿足！") ;
             }
         }
     }

程序運行結果如圖2-26所示。現在所有的判斷條件都執行了，所以造成了錯誤。

事實上，對于或運算，有一個條件返回true，后面不管有多少個true或false，最終結果都肯定是true，所以這樣的操作可以采用||完成。

圖2-26　|應用實例

【例2-25】（實例文件：ch02\Chap2.25.txt）||應用實例。

     public class Test {
         public static void main(String[] args) {
             if (1 == 1 ||1 / 0 == 0) {
                 System.out.println("條件滿足！") ;
             }
         }
     }

程序運行結果如圖2-27所示，說明沒有判斷1/0==0這個條件。||運算符判斷有一個條件是true，所有后面的條件就不再進行判斷，最終結果就是true。

圖2-27　||應用實例

2.6.5　賦值運算符

賦值運算符的主要功能是為各種不同類型的變量賦值，簡單的賦值運算由等號（=）來實現，就是把等號右邊的值賦予等號左邊的變量。例如：

     int x = 2048;

要注意=與==的不同。

在Java中，賦值運算符包括基本賦值運算符（=）和復合賦值運算符。復合賦值運算符是在基本賦值運算符的基礎上，結合算術運算符而形成的具有特殊意義的賦值運算符。賦值運算符及其應用實例如表2-9所示。

表2-9　賦值運算符及其應用實例

【例2-26】（實例文件：ch02\Chap2.26.txt）賦值運算符應用實例。

     public class Test {
         public static void main(String[] args) {
             int a = 10;
             int b = 20;
             System.out.println("a=" + a + ", b=" + b);
             a += b; //a+=b 相當于 a = a+b
             System.out.println("a += b, a=" + a);
         }
     }

程序運行結果如圖2-28所示。

圖2-28　賦值運算符應用實例

2.6.6　條件運算符

條件運算符（?:）也稱為三元運算符。語法形式如下：

     布爾表達式?表達式1:表達式2

其運算過程為：如果布爾表達式的值為true，則返回表達式1的值；否則返回表達式2的值。

【例2-27】（實例文件：ch02\Chap2.27.txt）條件運算符應用實例。

     public class Test {
         public static void main(String[] args) {
             int score = 68;
             String mark = (score >= 60) ? "及格" : "不及格";
             System.out.println("考試成績結果：" + mark);
         }
     }

程序運行結果如圖2-29所示。在上述代碼中，首先定義score為int類型，賦值68，通過比較，score>=60這個條件成立，結果為真，這樣會返回“及格”。如果定義score為50，則score>=60這個條件不成立，結果為假，這樣會返回“不及格”。

提示：條件運算也可以轉換為if語句，其實它就是if語句的簡寫版本。讀者如果覺得掌握條件運算有困難，也可以改寫為if語句，但閱讀代碼中的條件運算符時應該能夠理解其含義。

圖2-29　條件運算符應用實例

2.6.7　位運算符

位運算符主要用來對操作數的每個二進制位進行運算，其操作數的類型是整數類型以及字符型，運算的結果是整數類型。位運算符的含義及實例如表2-10所示。

表2-10　位運算符及其實例

【例2-28】（實例文件：ch02\Chap2.28.txt）位運算符應用實例。

     public class Test {
           public static void main(String[] args) {
              int a = 10;
              int b = 20;
              int c = 3;
              c <<= 2 ;
              System.out.println("c <<= 2 = " + c );
              c >>= 2 ;
              System.out.println("c >>= 2 = " + c );
              c >>= 2 ;
              System.out.println("c >>= a = " + c );
              c &= a ;
              System.out.println("c &= 2 = " + c );
              c ^= a ;
              System.out.println("c ^= a = " + c );
              c |= a ;
              System.out.println("c |= a = " + c );
           }
         }

程序運行結果如圖2-30所示。

圖2-30　位運算符應用實例

2.6.8　優先級與結合性

如果多個運算符出現在一個表達式中，怎么樣確定運算次序呢？這就涉及運算符的優先級的問題。在一個包含了多個運算符的表達式中，運算符優先級不同會導致最后得出的結果差別甚大。

例如，（1+3）+（3+2）*2，這個表達式如果按加號最優先計算，答案是18，如果按照乘號最優先，答案則是14。再如，x = 7 + 3 * 2;，這里x得到13，而不是20，因為乘法運算符比加法運算符有更高的優先級，所以先計算3 * 2得到6，然后再加7。

在表2-11中，最高優先級的運算符在表的最上面，最低優先級的運算符在表的最下面。

表2-11　Java運算符的優先級

2.7　就業面試解析與技巧

2.7.1　面試解析與技巧（一）

面試官：Java中有沒有goto？

應聘者：goto是Java中的保留字，但目前Java并沒用啟用goto。

2.7.2　面試解析與技巧（二）

面試官：String是基本數據類型嗎？

應聘者：基本數據類型包括byte、short、int、long、char、float、double和boolean。String不是基本數據類型，而是引用數據類型，其本質是一個類，因此String的首字母應該大寫。