Java軟體工程師是指運用Java這個開發工具去完成軟體產品的軟體程式設計、開發、測試、維護升級等工作的人員。 :::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 入門基礎知識 :::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 是由Sun Microsystems公司於1995年5月推出的高階程式設計語言。 Java可運行於多個平臺，如Windows, Mac OS，及其他多種UNIX版本的系統。 建立java檔案(檔名需與類名一致) String args[] 與 String[] args 都可以執行，但推薦使用 String[] args，這樣可以避免歧義和誤讀。 ::::::::::::::::::::::::::::::::::::::::::: Java 簡介 Java是由Sun Microsystems公司於1995年5月推出的Java面向物件程式設計語言和Java平臺的總稱。由James Gosling和同事們共同研發，並在1995年正式推出。 Java分為三個體系： http:/ /www.iis7.com/b/wzjk/ JavaSE(J2SE) (Java2 Platform Standard Edition，java平臺標準版) JavaEE(J2EE) (Java 2 Platform,Enterprise Edition，java平臺企業版) JavaME(J2ME) (Java 2 Platform Micro Edition，java平臺微型版)。 2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各種版本已經更名以取消其中的數字"2"：J2EE更名為Java EE, J2SE更名為Java SE，J2ME更名為Java ME。 。。。。。。 主要特性

1. Java語言是簡單的： Java語言的語法與C語言和C++語言很接近，使得大多數程式設計師很容易學習和使用。另一方面，Java丟棄了C++中很少使用的、很難理解的、令人迷惑的那些特性，如操作符過載、多繼承、自動的強制型別轉換。特別地，Java語言不使用指標，而是引用。並提供了自動的廢料收集，使得程式設計師不必為記憶體管理而擔憂。

2. Java語言是面向物件的： Java語言提供類、介面和繼承等面向物件的特性，為了簡單起見，只支援類之間的單繼承，但支援介面之間的多繼承，並支援類與介面之間的實現機制（關鍵字為implements）。Java語言全面支援動態繫結，而C++語言只對虛擬函式使用動態繫結。總之，Java語言是一個純的面向物件程式設計語言。

3. Java語言是分散式的： Java語言支援Internet應用的開發，在基本的Java應用程式設計介面中有一個網路應用程式設計介面（java net），它提供了用於網路應用程式設計的類庫，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（遠端方法啟用）機制也是開發分散式應用的重要手段。

4. Java語言是健壯的： Java的強型別機制、異常處理、垃圾的自動收集等是Java程式健壯性的重要保證。對指標的丟棄是Java的明智選擇。Java的安全檢查機制使得Java更具健壯性。

5. Java語言是安全的： Java通常被用在網路環境中，為此，Java提供了一個安全機制以防惡意程式碼的攻擊。除了Java語言具有的許多安全特性以外，Java對通過網路下載的類具有一個安全防範機制（類ClassLoader裝載器），如分配不同的名字空間以防替代本地的同名類、位元組程式碼檢查，並提供安全管理機制（類SecurityManager）讓Java應用設定安全哨兵。

6. Java語言是體系結構中立的： Java程式（字尾為java的檔案）在Java平臺上被編譯為體系結構中立的位元組碼格式（字尾為class的檔案），然後可以在實現這個Java平臺的任何系統中執行。這種途徑適合於異構的網路環境和軟體的分發。

7. Java語言是可移植的： 這種可移植性來源於體系結構中立性，另外，Java還嚴格規定了各個基本資料型別的長度。Java系統本身也具有很強的可移植性，Java編譯器是用Java實現的，Java的執行環境是用ANSI C實現的。

8. Java語言是解釋型的： 如前所述，Java程式在Java平臺上被編譯為位元組碼格式，然後可以在實現這個Java平臺的任何系統中執行。在執行時，Java平臺中的Java直譯器對這些位元組碼進行解釋執行，執行過程中需要的類在聯接階段被載入到執行環境中。

9. Java是高效能的： 與那些解釋型的高階指令碼語言相比，Java的確是高效能的。事實上，Java的執行速度隨著JIT(Just-In-Time）編譯器技術的發展越來越接近於C++。

10. Java語言是多執行緒的： 在Java語言中，執行緒是一種特殊的物件，它必須由Thread類或其子（孫）類來建立。通常有兩種方法來建立執行緒：其一，使用型構為Thread(Runnable)的構造子將一個實現了Runnable介面的物件包裝成一個執行緒，其二，從Thread類派生出子類並重寫run方法，使用該子類建立的物件即為執行緒。值得注意的是Thread類已經實現了Runnable介面，因此，任何一個執行緒均有它的run方法，而run方法中包含了執行緒所要執行的程式碼。執行緒的活動由一組方法來控制。Java語言支援多個執行緒的同時執行，並提供多執行緒之間的同步機制（關鍵字為synchronized）。

11. Java語言是動態的： Java語言的設計目標之一是適應於動態變化的環境。Java程式需要的類能夠動態地被載入到執行環境，也可以通過網路來載入所需要的類。這也有利於軟體的升級。另外，Java中的類有一個執行時刻的表示，能進行執行時刻的型別檢查。 。。。。。。 發展歷史 1995年5月23日，Java語言誕生 1996年1月，第一個JDK-JDK1.0誕生 1996年4月，10個最主要的作業系統供應商申明將在其產品中嵌入JAVA技術 1996年9月，約8.3萬個網頁應用了JAVA技術來製作 1997年2月18日，JDK1.1釋出 1997年4月2日，JavaOne會議召開，參與者逾一萬人，創當時全球同類會議規模之紀錄 1997年9月，JavaDeveloperConnection社群成員超過十萬 1998年2月，JDK1.1被下載超過2,000,000次 1998年12月8日，JAVA2企業平臺J2EE釋出 1999年6月，SUN公司釋出Java的三個版本：標準版（JavaSE,以前是J2SE）、企業版（JavaEE以前是J2EE）和微型版（JavaME，以前是J2ME） 2000年5月8日，JDK1.3釋出 2000年5月29日，JDK1.4釋出 2001年6月5日，NOKIA宣佈，到2003年將出售1億部支援Java的手機 2001年9月24日，J2EE1.3釋出 2002年2月26日，J2SE1.4釋出，自此Java的計算能力有了大幅提升 2004年9月30日18:00PM，J2SE1.5釋出，成為Java語言發展史上的又一里程碑。為了表示該版本的重要性，J2SE1.5更名為Java SE 5.0 2005年6月，JavaOne大會召開，SUN公司公開Java SE 6。此時，Java的各種版本已經更名，以取消其中的數字"2"：J2EE更名為Java EE，J2SE更名為Java SE，J2ME更名為Java ME 2006年12月，SUN公司釋出JRE6.0 2009年04月20日，甲骨文74億美元收購Sun。取得java的版權。 2010年11月，由於甲骨文對於Java社群的不友善，因此Apache揚言將退出JCP[4]。 2011年7月28日，甲骨文釋出java7.0的正式版。 2014年3月18日，Oracle公司發表Java SE 8。 。。。。。。 JDK環境配置：

12. 到官網下載JDK

13. 安裝(根據提示就可以)

14. 開啟我的電腦–高階系統設定–系統變數 新增JAVA_HOME：根據自己的實際安裝路徑來新增 新增CLASSPATH： .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //記得前面有個"." 編輯系統變數的path：在最前面加上：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; 然後在開始那裡找到cmd輸入java -version，java，javac，看看是否搭建成功。 。。。。。。 Java開發工具 Java語言儘量保證系統記憶體在1G以上，其他工具如下所示： Linux 系統、Mac OS 系統、Windows 95/98/2000/XP，WIN 7/8系統。 Java JDK 7、8…… Notepad 編輯器或者其他編輯器。 IDE：Eclipse 安裝好以上的工具後，我們就可以輸出Java的第一個程式"Hello World！" :::::::::::::::::::::::::::::::::::::::::::::::: Java 基礎語法 一個Java程式可以認為是一系列物件的集合，而這些物件通過呼叫彼此的方法來協同工作。下面簡要介紹下類、物件、方法和例項變數的概念。 物件：物件是類的一個例項，有狀態和行為。例如，一條狗是一個物件，它的狀態有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。 類：類是一個模板，它描述一類物件的行為和狀態。 方法：方法就是行為，一個類可以有很多方法。邏輯運算、資料修改以及所有動作都是在方法中完成的。 例項變數：每個物件都有獨特的例項變數，物件的狀態由這些例項變數的值決定。 。。。。。。 基本語法 編寫Java程式時，應注意以下幾點： 大小寫敏感：Java是大小寫敏感的，這就意味著識別符號Hello與hello是不同的。 類名：對於所有的類來說，類名的首字母應該大寫。如果類名由若干單片語成，那麼每個單詞的首字母應該大寫，例如 MyFirstJavaClass 。 方法名：所有的方法名都應該以小寫字母開頭。如果方法名含有若干單詞，則後面的每個單詞首字母大寫。 原始檔名：原始檔名必須和類名相同。當儲存檔案的時候，你應該使用類名作為檔名儲存（切記Java是大小寫敏感的），檔名的字尾為.java。（如果檔名和類名不相同則會導致編譯錯誤） 主方法入口：所有的Java 程式由public static void main(String []args)方法開始執行。 。。。。。。 Java識別符號 Java所有的組成部分都需要名字。類名、變數名以及方法名都被稱為識別符號。 關於Java識別符號，有以下幾點需要注意： 所有的識別符號都應該以字母（A-Z或者a-z）,美元符（$）、或者下劃線（_）開始 首字元之後可以是字母（A-Z或者a-z）,美元符（$）、下劃線（_）或數字的任何字元組合 關鍵字不能用作識別符號 識別符號是大小寫敏感的 合法識別符號舉例：age、$salary、_value、__1_value 非法識別符號舉例：123abc、-salary 。。。。。。 Java修飾符 像其他語言一樣，Java可以使用修飾符來修飾類中方法和屬性。主要有兩類修飾符： 訪問控制修飾符 : default, public , protected, private 非訪問控制修飾符 : final, abstract, strictfp 。。。。。。 Java變數 Java中主要有如下幾種型別的變數 區域性變數 類變數（靜態變數） 成員變數（非靜態變數） 。。。。。。 Java陣列 陣列是儲存在堆上的物件，可以儲存多個同類型變數。 。。。。。。 Java列舉 Java 5.0引入了列舉，列舉限制變數只能是預先設定好的值。使用列舉可以減少程式碼中的bug。 例如，我們為果汁店設計一個程式，它將限制果汁為小杯、中杯、大杯。這就意味著它不允許顧客點除了這三種尺寸外的果汁。 注意：列舉可以單獨宣告或者宣告在類裡面。方法、變數、建構函式也可以在列舉中定義。 。。。。。。 Java關鍵字 下面列出了Java保留字。這些保留字不能用於常量、變數、和任何識別符號的名稱。 關鍵字 描述 abstract 抽象方法，抽象類的修飾符 assert 斷言條件是否滿足 boolean 布林資料型別 break 跳出迴圈或者label程式碼段 byte 8-bit 有符號資料型別 case switch 語句的一個條件 catch 和try搭配捕捉異常資訊 char 16-bit Unicode字元資料型別 class 定義類 const 未使用 continue 不執行迴圈體剩餘部分 default switch語句中的預設分支 do 迴圈語句，迴圈體至少會執行一次 double 64-bit雙精度浮點數 else if條件不成立時執行的分支 enum 列舉型別 extends 表示一個類是另一個類的子類 final 表示一個值在初始化之後就不能再改變了，表示方法不能被重寫，或者一個類不能有子類 finally 為了完成執行的程式碼而設計的，主要是為了程式的健壯性和完整性，無論有沒有異常發生都執行程式碼。 float 32-bit單精度浮點數 for for迴圈語句 goto 未使用 if 條件語句 implements 表示一個類實現了介面 import 匯入類 instanceof 測試一個物件是否是某個類的例項 int 32位整型數 interface 介面，一種抽象的型別，僅有方法和常量的定義 long 64位整型數 native 表示方法用非java程式碼實現 new 分配新的類例項 package 一系列相關類組成一個包 private 表示私有欄位，或者方法等，只能從類內部訪問 protected 表示欄位只能通過類或者其子類訪問，子類或者在同一個包內的其他類 public 表示共有屬性或者方法 return 方法返回值 short 16位數字 static 表示在類級別定義，所有例項共享的 strictfp 浮點數比較使用嚴格的規則 super 表示基類 switch 選擇語句 synchronized 表示同一時間只能由一個執行緒訪問的程式碼塊 this 表示呼叫當前例項，或者呼叫另一個建構函式 throw 丟擲異常 throws 定義方法可能丟擲的異常 transient 修飾不要序列化的欄位 try 表示程式碼塊要做異常處理或者和finally配合表示是否丟擲異常都執行finally中的程式碼 void 標記方法不返回任何值 volatile 標記欄位可能會被多個執行緒同時訪問，而不做同步 while while迴圈 。。。。。。 Java註釋 java中的，//單行註釋 java中的，/多行註釋/ 類似於C/C++，Java也支援單行以及多行註釋。註釋中的字元將被Java編譯器忽略。 。。。。。。 Java 空行 空白行，或者有註釋的的行，Java編譯器都會忽略掉。 。。。。。。 繼承 在Java中，一個類可以由其他類派生。如果你要建立一個類，而且已經存在一個類具有你所需要的屬性或方法，那麼你可以將新建立的類繼承該類。 利用繼承的方法，可以重用已存在類的方法和屬性，而不用重寫這些程式碼。被繼承的類稱為超類（super class），派生類稱為子類（subclass）。 。。。。。。 介面 在Java中，介面可理解為物件間相互通訊的協議。介面在繼承中扮演著很重要的角色。 介面只定義派生要用到的方法，但是方法的具體實現完全取決於派生類。 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 物件和類 Java作為一種面嚮物件語言。支援以下基本概念： ：多型 ：繼承 ：封裝 ：抽象 ：類 ：物件 ：例項 ：方法 ：訊息解析 。。。。。。 我們先來研究物件和類的概念。 物件：物件是類的一個例項，有狀態和行為。例如，一條狗是一個物件，它的狀態有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。 類：類是一個模板，它描述一類物件的行為和狀態。(抽象類：如動物，人等) 。。。 Java中的物件 現在讓我們深入瞭解什麼是物件。看看周圍真實的世界，會發現身邊有很多物件，車，狗，人等等。所有這些物件都有自己的狀態和行為。 拿一條狗來舉例，它的狀態有：名字、品種、顏色，行為有：叫、搖尾巴和跑。 對比現實物件和軟體物件，它們之間十分相似。 軟體物件也有狀態和行為。軟體物件的狀態就是屬性，行為通過方法體現。 在軟體開發中，方法操作物件內部狀態的改變，物件的相互呼叫也是通過方法來完成。 。。。 Java中的類 類可以看成是建立Java物件的模板。 通過下面一個簡單的類來理解下Java中類的定義： public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } } 一個類可以包含以下型別變數： 區域性變數：在方法、構造方法或者語句塊中定義的變數被稱為區域性變數。變數宣告和初始化都是在方法中，方法結束後，變數就會自動銷燬。 成員變數：成員變數是定義在類中，方法體之外的變數。這種變數在建立物件的時候例項化。成員變數可以被類中方法、構造方法和特定類的語句塊訪問。 類變數：類變數也宣告在類中，方法體之外，但必須宣告為static型別。 一個類可以擁有多個方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog類的方法。 。。。 構造方法 每個類都有構造方法。如果沒有顯式地為類定義構造方法，Java編譯器將會為該類提供一個預設構造方法。 在建立一個物件的時候，至少要呼叫一個構造方法。構造方法的名稱必須與類同名，一個類可以有多個構造方法。 下面是一個構造方法示例： public class Puppy{ public Puppy(){ } public Puppy(String name){ // 這個構造器僅有一個引數：name } } 。。。 建立物件 物件是根據類建立的。在Java中，使用關鍵字new來建立一個新的物件。建立物件需要以下三步： 宣告：宣告一個物件，包括物件名稱和物件型別。 例項化：使用關鍵字new來建立一個物件。 初始化：使用new建立物件時，會呼叫構造方法初始化物件。 下面是一個建立物件的例子： public class Puppy{ public Puppy(String name){ //這個構造器僅有一個引數：name System.out.println(“Passed Name is :” + name ); } public static void main(String []args){ // 下面的語句將建立一個Puppy物件 Puppy myPuppy = new Puppy( “tommy” ); } } 編譯並執行上面的程式，會打印出右面的結果：Passed Name is :tommy 。。。 訪問例項變數和方法 通過已建立的物件來訪問成員變數和成員方法，如下所示： /* 例項化物件 / ObjectReference = new Constructor(); / 訪問其中的變數 / ObjectReference.variableName; / 訪問類中的方法 / ObjectReference.MethodName(); 。。。 例項 下面的例子展示如何訪問例項變數和呼叫成員方法： public class Puppy{ int puppyAge; public Puppy(String name){ // 這個構造器僅有一個引數：name System.out.println(“Passed Name is :” + name ); } public void setAge( int age ){ puppyAge = age; } public int getAge( ){ System.out.println(“Puppy’s age is :” + puppyAge ); return puppyAge; } public static void main(String []args){ / 建立物件 / Puppy myPuppy = new Puppy( “tommy” ); / 通過方法來設定age / myPuppy.setAge( 2 ); / 呼叫另一個方法獲取age / myPuppy.getAge( ); /你也可以像下面這樣訪問成員變數 / System.out.println(“Variable Value :” + myPuppy.puppyAge ); } } 編譯並執行上面的程式，產生如下結果： Passed Name is :tommy Puppy’s age is :2 Variable Value :2 。。。 原始檔宣告規則 我們來學習原始檔的宣告規則。當在一個原始檔中定義多個類，並且還有import語句和package語句時，要特別注意這些規則。 一個原始檔中只能有一個public類 一個原始檔可以有多個非public類 原始檔的名稱應該和public類的類名保持一致。例如：原始檔中public類的類名是Employee，那麼原始檔應該命名為Employee.java。 如果一個類定義在某個包中，那麼package語句應該在原始檔的首行。 如果原始檔包含import語句，那麼應該放在package語句和類定義之間。如果沒有package語句，那麼import語句應該在原始檔中最前面。 import語句和package語句對原始檔中定義的所有類都有效。在同一原始檔中，不能給不同的類不同的包宣告。 類有若干種訪問級別，並且類也分不同的型別：抽象類和final類等。 除了上面提到的幾種型別，Java還有一些特殊的類，如：內部類、匿名類。 。。。 Java包 包主要用來對類和介面進行分類。當開發Java程式時，可能編寫成百上千的類，因此很有必要對類和介面進行分類。 。。。 import語句 在Java中，如果給出一個完整的限定名，包括包名、類名，那麼Java編譯器就可以很容易地定位到原始碼或者類。import語句就是用來提供一個合理的路徑，使得編譯器可以找到某個類。 例如，右面的命令列將會命令編譯器載入java_installation/java/io路徑下的所有類，import java.io.; 一個簡單的例子 在該例子中，我們建立兩個類：Employee和EmployeeTest。 首先開啟文字編輯器，把下面的程式碼貼上進去。注意將檔案儲存為Employee.java。 Employee類有四個成員變數：name、age、designation和salary。該類顯式聲明瞭一個構造方法，該方法只有一個引數。 import java.io.; public class Employee{ String name; int age; String designation; double salary; // Employee 類的構造器 public Employee(String name){ this.name = name; } // 設定age的值 public void empAge(int empAge){ age = empAge; } / 設定designation的值*/ public void empDesignation(String empDesig){ designation = empDesig; } /* 設定salary的值*/ public void empSalary(double empSalary){ salary = empSalary; } /* 列印資訊 / public void printEmployee(){ System.out.println(“Name:”+ name ); System.out.println(“Age:” + age ); System.out.println(“Designation:” + designation ); System.out.println(“Salary:” + salary); } } 程式都是從main方法開始執行。為了能執行這個程式，必須包含main方法並且建立一個例項物件。 下面給出EmployeeTest類，該類例項化2個Employee類的例項，並呼叫方法設定變數的值。 將下面的程式碼儲存在EmployeeTest.java檔案中。 import java.io.; public class EmployeeTest{

    public static void main(String args[]){ /* 使用構造器建立兩個物件 */ Employee empOne = new Employee(“James Smith”); Employee empTwo = new Employee(“Mary Anne”);

    // 呼叫這兩個物件的成員方法 empOne.empAge(26); empOne.empDesignation(“Senior Software Engineer”); empOne.empSalary(1000); empOne.printEmployee();

    empTwo.empAge(21); empTwo.empDesignation(“Software Engineer”); empTwo.empSalary(500); empTwo.printEmployee(); } } 編譯這兩個檔案並且執行EmployeeTest類，可以看到如下結果： C :> javac Employee.java C :> vi EmployeeTest.java C :> javac EmployeeTest.java C :> java EmployeeTest Name:James Smith Age:26 Designation:Senior Software Engineer Salary:1000.0 Name:Mary Anne Age:21 Designation:Software Engineer Salary:500.0 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 基本資料型別 變數就是申請記憶體來儲存值。也就是說，當建立變數的時候，需要在記憶體中申請空間。 記憶體管理系統根據變數的型別為變數分配儲存空間，分配的空間只能用來儲存該型別資料。 因此，通過定義不同型別的變數，可以在記憶體中儲存整數、小數或者字元。 Java的兩大資料型別：內建資料型別，引用資料型別 。。。 內建資料型別 Java語言提供了八種基本型別。六種數字型別（四個整數型，兩個浮點型），一種字元型別，還有一種布林型。 byte： byte資料型別是8位、有符號的，以二進位制補碼錶示的整數； 最小值是-128（-2^7）； 最大值是127（2^7-1）； 預設值是0； byte型別用在大型陣列中節約空間，主要代替整數，因為byte變數佔用的空間只有int型別的四分之一； 例子：byte a = 100，byte b = -50。 short： short資料型別是16位、有符號的以二進位制補碼錶示的整數 最小值是-32768（-2^15）； 最大值是32767（2^15 - 1）； Short資料型別也可以像byte那樣節省空間。一個short變數是int型變數所佔空間的二分之一； 預設值是0； 例子：short s = 1000，short r = -20000。 int： int資料型別是32位、有符號的以二進位制補碼錶示的整數； 最小值是-2,147,483,648（-2^31）； 最大值是2,147,483,647（2^31 - 1）； 一般地整型變數預設為int型別； 預設值是0； 例子：int a = 100000, int b = -200000。 long： long資料型別是64位、有符號的以二進位制補碼錶示的整數； 最小值是-9,223,372,036,854,775,808（-2^63）； 最大值是9,223,372,036,854,775,807（2^63 -1）； 這種型別主要使用在需要比較大整數的系統上； 預設值是0L； 例子： long a = 100000L，long b = -200000L。 float： float資料型別是單精度、32位、符合IEEE 754標準的浮點數； float在儲存大型浮點陣列的時候可節省記憶體空間； 預設值是0.0f； 浮點數不能用來表示精確的值，如貨幣； 例子：float f1 = 234.5f。 double： double資料型別是雙精度、64位、符合IEEE 754標準的浮點數； 浮點數的預設型別為double型別； double型別同樣不能表示精確的值，如貨幣； 預設值是0.0d； 例子：double d1 = 123.4。 boolean： boolean資料型別表示一位的資訊； 只有兩個取值：true和false； 這種型別只作為一種標誌來記錄true/false情況； 預設值是false； 例子：boolean one = true。 char： char型別是一個單一的16位Unicode字元； 最小值是’\u0000’（即為0）； 最大值是’\uffff’（即為65,535）； char資料型別可以儲存任何字元； 例子：char letter = ‘A’。 對於數值型別的基本型別的取值範圍，我們無需強制去記憶，因為它們的值都已經以常量的形式定義在對應的包裝類中了。 Float和Double的最小值和最大值都是以科學記數法的形式輸出的，結尾的"E+數字"表示E之前的數字要乘以10的“數字”次冪。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。 實際上，JAVA中還存在另外一種基本型別void，它也有對應的包裝類 java.lang.Void，不過我們無法直接對它們進行操作。 。。。 引用型別 引用型別變數由類的建構函式建立，可以使用它們訪問所引用的物件。這些變數在宣告時被指定為一個特定的型別，比如Employee、Pubby等。變數一旦聲明後，型別就不能被改變了。 物件、陣列都是引用資料型別。 所有引用型別的預設值都是null。 一個引用變數可以用來引用與任何與之相容的型別。例子：Animal animal = new Animal(“giraffe”)。 。。。 Java常量 常量就是一個固定值。它們不需要計算，直接代表相應的值。 常量指不能改變的量。 在Java中用final標誌，宣告方式和變數類似： final double PI = 3.1415927; 雖然常量名也可以用小寫，但為了便於識別，通常使用大寫字母表示常量。 字面量可以賦給任何內建型別的變數。例如： byte a = 68; char a = ‘A’ byte、int、long、和short都可以用十進位制、16進位制以及8進位制的方式來表示。 當使用常量的時候，字首0表明是8進位制，而字首0x代表16進位制。例如： int decimal = 100; int octal = 0144; int hexa = 0x64; 和其他語言一樣，Java的字串常量也是包含在兩個引號之間的字元序列。下面是字串型字面量的例子： “Hello World” “two\nlines” ““This is in quotes”” 字串常量和字元常量都可以包含任何Unicode字元。例如： char a = ‘\u0001’; String a = “\u0001”; Java語言支援一些特殊的轉義字元序列。 符號 字元含義 \n 換行 (0x0a) \r 回車 (0x0d) \f 換頁符(0x0c) \b 退格 (0x08) \s 空格 (0x20) \t 製表符 " 雙引號 ’ 單引號 \ 反斜槓 \ddd 八進位制字元 (ddd) \uxxxx 16進位制Unicode字元 (xxxx) ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 變數型別 在Java語言中，所有的變數在使用前必須宣告。宣告變數的基本格式如右：type identifier [ = value][, identifier [= value] …] ; 格式說明：type為Java資料型別。identifier是變數名。可以使用逗號隔開來宣告多個同類型變數。 以下列出了一些變數的宣告例項。注意有些包含了初始化過程。 int a, b, c; // 宣告三個int型整數：a、b、c。 int d = 3, e, f = 5; // 宣告三個整數並賦予初值。 byte z = 22; // 宣告並初始化z。 double pi = 3.14159; // 聲明瞭pi。 char x = ‘x’; // 變數x的值是字元’x’。 Java語言支援的變數型別有：區域性變數，例項變數，類變數 。。。 Java區域性變數 -區域性變數宣告在方法、構造方法或者語句塊中； -區域性變數在方法、構造方法、或者語句塊被執行的時候建立，當它們執行完成後，變數將會被銷燬； -訪問修飾符不能用於區域性變數； -區域性變數只在宣告它的方法、構造方法或者語句塊中可見； -區域性變數是在棧上分配的。 -區域性變數沒有預設值，所以區域性變數被聲明後，必須經過初始化，才可以使用。 例項1 在以下例項中age是一個區域性變數。定義在pupAge()方法中，它的作用域就限制在這個方法中。 public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("Puppy age is : " + age); }

    public static void main(String args[]){ Test test = new Test(); test.pupAge(); } } 以上例項編譯執行結果如右：Puppy age is: 7 例項2 在下面的例子中age變數沒有初始化，所以在編譯時出錯。 public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("Puppy age is : " + age); }

    public static void main(String args[]){ Test test = new Test(); test.pupAge(); } } 以上例項編譯執行結果如下: Test.java:4:variable number might not have been initialized age = age + 7; ^ 1 error 。。。 Java例項變數 -例項變數宣告在一個類中，但在方法、構造方法和語句塊之外； -當一個物件被例項化之後，每個例項變數的值就跟著確定； -例項變數在物件建立的時候建立，在物件被銷燬的時候銷燬； -例項變數的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取例項變數資訊； -例項變數可以宣告在使用前或者使用後； -訪問修飾符可以修飾例項變數； -例項變數對於類中的方法、構造方法或者語句塊是可見的。一般情況下應該把例項變數設為私有。通過使用訪問修飾符可以使例項變數對子類可見； -例項變數具有預設值。數值型變數的預設值是0，布林型變數的預設值是false，引用型別變數的預設值是null。變數的值可以在宣告時指定，也可以在構造方法中指定； -例項變數可以直接通過變數名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。 例項子： import java.io.*; public class Employee{ // 這個成員變數對子類可見 public String name; // 私有變數，僅在該類可見 private double salary; //在構造器中對name賦值 public Employee (String empName){ name = empName; } //設定salary的值 public void setSalary(double empSal){ salary = empSal; } // 列印資訊 public void printEmp(){ System.out.println("name : " + name ); System.out.println(“salary :” + salary); }

    public static void main(String args[]){ Employee empOne = new Employee(“Ransika”); empOne.setSalary(1000); empOne.printEmp(); } } 以上例項編譯執行結果如下: name : Ransika salary :1000.0 。。。 Java類變數（靜態變數） -類變數也稱為靜態變數，在類中以static關鍵字宣告，但必須在方法、構造方法和語句塊之外。 -無論一個類建立了多少個物件，類只擁有類變數的一份拷貝。 -靜態變數除了被宣告為常量外很少使用。常量是指宣告為public/private，final和static型別的變數。常量初始化後不可改變。 -靜態變數儲存在靜態儲存區。經常被宣告為常量，很少單獨使用static宣告變數。 -靜態變數在程式開始時建立，在程式結束時銷燬。 -與例項變數具有相似的可見性。但為了對類的使用者可見，大多數靜態變數宣告為public型別。 -預設值和例項變數相似。數值型變數預設值是0，布林型預設值是false，引用型別預設值是null。變數的值可以在宣告的時候指定，也可以在構造方法中指定。此外，靜態變數還可以在靜態語句塊中初始化。 -靜態變數可以通過：ClassName.VariableName的方式訪問。 -類變數被宣告為public static final型別時，類變數名稱必須使用大寫字母。如果靜態變數不是public和final型別，其命名方式與例項變數以及區域性變數的命名方式一致。 例項子： import java.io.*; public class Employee{ //salary是靜態的私有變數 private static double salary; // DEPARTMENT是一個常量 public static final String DEPARTMENT = "Development "; public static void main(String args[]){ salary = 1000; System.out.println(DEPARTMENT+“average salary:”+salary); } } 以上例項編譯執行結果如下: Development average salary:1000 注意：如果其他類想要訪問該變數，可以這樣訪問：Employee.DEPARTMENT。 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 修飾符 Java語言提供了很多修飾符，主要分為兩類：訪問修飾符，非訪問修飾符 修飾符用來定義類、方法或者變數，通常放在語句的最前端。我們通過下面的例子來說明： public class className { // … } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // 方法體 } 。。。 訪問控制修飾符 -Java中，可以使用訪問控制符來保護對類、變數、方法和構造方法的訪問。Java支援4種不同的訪問許可權。 -預設的，也稱為default，在同一包內可見，不使用任何修飾符。 -私有的，以private修飾符指定，在同一類內可見。 -共有的，以public修飾符指定，對所有類可見。 -受保護的，以protected修飾符指定，對同一包內的類和所有子類可見。

15. 預設訪問修飾符-不使用任何關鍵字 使用預設訪問修飾符宣告的變數和方法，對同一個包內的類是可見的。接口裡的變數都隱式宣告為public static final,而接口裡的方法預設情況下訪問許可權為public。 例項： 如下例所示，變數和方法的宣告可以不使用任何修飾符。 String version = “1.5.1”; boolean processOrder() { return true; }

16. 私有訪問修飾符-private 私有訪問修飾符是最嚴格的訪問級別，所以被宣告為private的方法、變數和構造方法只能被所屬類訪問，並且類和介面不能宣告為private。 宣告為私有訪問型別的變數只能通過類中公共的getter方法被外部類訪問。 Private訪問修飾符的使用主要用來隱藏類的實現細節和保護類的資料。 下面的類使用了私有訪問修飾符： public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; } } 例項中，Logger類中的format變數為私有變數，所以其他類不能直接得到和設定該變數的值。為了使其他類能夠操作該變數，定義了兩個public方法：getFormat() （返回format的值）和setFormat(String)（設定format的值）

17. 公有訪問修飾符-public 被宣告為public的類、方法、構造方法和介面能夠被任何其他類訪問。 如果幾個相互訪問的public類分佈在不同的包中，則需要匯入相應public類所在的包。由於類的繼承性，類所有的公有方法和變數都能被其子類繼承。 以下函式使用了公有訪問控制： public static void main(String[] arguments) { // … } Java程式的main() 方法必須設定成公有的，否則，Java直譯器將不能執行該類。

18. 受保護的訪問修飾符-protected 被宣告為protected的變數、方法和構造器能被同一個包中的任何其他類訪問，也能夠被不同包中的子類訪問。 Protected訪問修飾符不能修飾類和介面，方法和成員變數能夠宣告為protected，但是介面的成員變數和成員方法不能宣告為protected。 子類能訪問Protected修飾符宣告的方法和變數，這樣就能保護不相關的類使用這些方法和變數。 下面的父類使用了protected訪問修飾符，子類過載了父類的openSpeaker()方法。 class AudioPlayer { protected boolean openSpeaker(Speaker sp) { // 實現細節 } }

class StreamingAudioPlayer { boolean openSpeaker(Speaker sp) { // 實現細節 } } 如果把openSpeaker()方法宣告為private，那麼除了AudioPlayer之外的類將不能訪問該方法。如果把openSpeaker()宣告為public，那麼所有的類都能夠訪問該方法。如果我們只想讓該方法對其所在類的子類可見，則將該方法宣告為protected。 。。 訪問控制和繼承 請注意以下方法繼承的規則： -父類中宣告為public的方法在子類中也必須為public。 -父類中宣告為protected的方法在子類中要麼宣告為protected，要麼宣告為public。不能宣告為private。 -父類中預設修飾符宣告的方法，能夠在子類中宣告為private。 -父類中宣告為private的方法，不能夠被繼承。 。。。。。。 非訪問修飾符 為了實現一些其他的功能，Java也提供了許多非訪問修飾符。 static修飾符，用來建立類方法和類變數。 final修飾符，用來修飾類、方法和變數，final修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變數為常量，是不可修改的。 abstract修飾符，用來建立抽象類和抽象方法。 synchronized和volatile修飾符，主要用於執行緒的程式設計。 。。。

1. static修飾符 靜態變數： static關鍵字用來宣告獨立於物件的靜態變數，無論一個類例項化多少物件，它的靜態變數只有一份拷貝。靜態變數也被稱為類變數。區域性變數不能被宣告為static變數。 靜態方法： static關鍵字用來宣告獨立於物件的靜態方法。靜態方法不能使用類的非靜態變數。靜態方法從引數列表得到資料，然後計算這些資料。 對類變數和方法的訪問可以直接使用classname.variablename和classname.methodname的方式訪問。
2. final修飾符 final變數： final變數能被顯式地初始化並且只能初始化一次。被宣告為final的物件的引用不能指向不同的物件。但是final物件裡的資料可以被改變。也就是說final物件的引用不能改變，但是裡面的值可以改變。 final修飾符通常和static修飾符一起使用來建立類常量。 。。 final方法 類中的Final方法可以被子類繼承，但是不能被子類修改。 宣告final方法的主要目的是防止該方法的內容被修改。 。。 final類 final類不能被繼承，沒有類能夠繼承final類的任何特性。
3. abstract修飾符 抽象類： 抽象類不能用來例項化物件，宣告抽象類的唯一目的是為了將來對該類進行擴充。 一個類不能同時被abstract和final修飾。如果一個類包含抽象方法，那麼該類一定要宣告為抽象類，否則將出現編譯錯誤。 抽象類可以包含抽象方法和非抽象方法。 。。 抽象方法 抽象方法是一種沒有任何實現的方法，該方法的的具體實現由子類提供。抽象方法不能被宣告成final和static。 任何繼承抽象類的子類必須實現父類的所有抽象方法，除非該子類也是抽象類。 如果一個類包含若干個抽象方法，那麼該類必須宣告為抽象類。抽象類可以不包含抽象方法。 抽象方法的宣告以分號結尾，例如：public abstract sample();
4. synchronized修飾符 synchronized關鍵字宣告的方法同一時間只能被一個執行緒訪問。Synchronized修飾符可以應用於四個訪問修飾符。
5. transient修飾符 序列化的物件包含被transient修飾的例項變數時，java虛擬機器(JVM)跳過該特定的變數。 該修飾符包含在定義變數的語句中，用來預處理類和變數的資料型別。
6. volatile修飾符 volatile修飾的成員變數在每次被執行緒訪問時，都強迫從共享記憶體中重讀該成員變數的值。而且，當成員變數發生變化時，強迫執行緒將變化值回寫到共享記憶體。這樣在任何時刻，兩個不同的執行緒總是看到某個成員變數的同一個值。一個volatile物件引用可能是null。 ::::::::::::::::::::::::::::::::::::::::::::::::: Java 運算子 計算機的最基本用途之一就是執行數學運算，作為一門計算機語言，Java也提供了一套豐富的運算子來操縱變數。我們可以把運算子分成以下幾組：
7. 算術運算子
8. 關係運算符
9. 位運算子
10. 邏輯運算子
11. 賦值運算子
12. 其他運算子 。。。 算術運算子 算術運算子用在數學表示式中，它們的作用和在數學中的作用一樣。下表列出了所有的算術運算子。 下面的例項假設整數變數A的值為10，變數B的值為20： 操作符 描述 例子

•            加法 - 相加運算子兩側的值	               A + B等於30
  

•            減法 - 左運算元減去右運算元	           A – B等於-10
  

•            乘法 - 相乘操作符兩側的值	               A * B等於200
  

/ 除法 - 左運算元除以右運算元 B / A等於2 ％ 取模 - 左運算元除以右運算元的餘數 B%A等於0 ++ 自增 - 運算元的值增加1 B++ 或 ++B 等於 21 – 自減 - 運算元的值減少1 B-- 或 --B 等於 19 。。。 關係運算符 下面為Java支援的關係運算符 下面中的例項整數變數A的值為10，變數B的值為20： 運算子 描述 例子 == 檢查如果兩個運算元的值是否相等，如果相等則條件為真。 （A == B）為假(非真)。 != 檢查如果兩個運算元的值是否相等，如果值不相等則條件為真。 (A != B) 為真。

          檢查左運算元的值是否大於右運算元的值，如果是那麼條件為真。	            （A> B）非真。

< 檢查左運算元的值是否小於右運算元的值，如果是那麼條件為真。 （A <B）為真。

= 檢查左運算元的值是否大於或等於右運算元的值，如果是那麼條件為真。 （A> = B）為假。 <= 檢查左運算元的值是否小於或等於右運算元的值，如果是那麼條件為真。 （A <= B）為真。 。。。 位運算子 Java定義了位運算子，應用於整數型別(int)，長整型(long)，短整型(short)，字元型(char)，和位元組型(byte)等型別。 位運算子作用在所有的位上，並且按位運算。假設a = 60，和b = 13;它們的二進位制格式表示將如下： A = 0011 1100 B = 0000 1101

A&b = 0000 1100 A | B = 0011 1101 A ^ B = 0011 0001 ~A= 1100 0011 下面列出了位運算子的基本運算,假設整數變數A的值為60和變數B的值為13： 操作符 描述 例子 ＆ 按位與操作符，當且僅當兩個運算元的某一位都非0時候結果的該位才為1。 （A＆B） 得到12，即0000 1100 | 按位或操作符，只要兩個運算元的某一位有一個非0時候結果的該位就為1。 （A | B） 得到61，即 0011 1101 ^ 按位異或操作符，兩個運算元的某一位不相同時候結果的該位就為1。 （A ^ B）得到49，即 0011 0001 ? 按位補運算子翻轉運算元的每一位。 （?A） 得到-60，即1100 0011 << 按位左移運算子。左運算元按位左移右運算元指定的位數。 A << 2 得到240，即 1111 0000

     按位右移運算子。左運算元按位右移右運算元指定的位數。	                                                A >> 2   得到15即 1111

 按位右移補零操作符。左運算元的值按右運算元指定的位數右移，移動得到的空位以零填充。	A>>>2   得到15即0000 1111

。。。 邏輯運算子 下面列出了邏輯運算子的基本運算，假設布林變數A為真，變數B為假 操作符 描述 例子 && 稱為邏輯與運算子。當且僅當兩個運算元都為真，條件才為真。 （A && B）為假。 | | 稱為邏輯或操作符。如果任何兩個運算元任何一個為真，條件為真。 （A | | B）為真。 ！ 稱為邏輯非運算子。用來反轉運算元的邏輯狀態。如果條件為true，則邏輯非運算子將得到false。 ！（A && B）為真。 。。。 賦值運算子 下面是Java語言支援的賦值運算子： 操作符 描述 例子 = 簡單的賦值運算子，將右運算元的值賦給左側運算元 C = A + B將把A + B得到的值賦給C

• = 加和賦值操作符，它把左運算元和右運算元相加賦值給左運算元 C + = A等價於C = C + A

• = 減和賦值操作符，它把左運算元和右運算元相減賦值給左運算元 C - = A等價於C = C -A

• = 乘和賦值操作符，它把左運算元和右運算元相乘賦值給左運算元 C * = A等價於C = C * A / = 除和賦值操作符，它把左運算元和右運算元相除賦值給左運算元 C / = A等價於C = C / A （％）= 取模和賦值操作符，它把左運算元和右運算元取模後賦值給左運算元 C％= A等價於C = C％A << = 左移位賦值運算子 C << = 2等價於C = C << 2

= 右移位賦值運算子 C >> = 2等價於C = C >> 2 ＆= 按位與賦值運算子 C＆= 2等價於C = C＆2 ^ = 按位異或賦值操作符 C ^ = 2等價於C = C ^ 2 | = 按位或賦值操作符 C | = 2等價於C = C | 2 。。。 條件運算子（?:） 條件運算子也被稱為三元運算子。該運算子有3個運算元，並且需要判斷布林表示式的值。該運算子的主要是決定哪個值應該賦值給變數。 variable x = (expression) ? value if true : value if false 。。。 instanceOf 運算子 該運算子用於操作物件例項，檢查該物件是否是一個特定型別（類型別或介面型別）。 instanceof運算子使用格式如右：( Object reference variable ) instanceOf (class/interface type) 如果運算子左側變數所指的物件，是操作符右側類或介面(class/interface)的一個物件，那麼結果為真。 。。。 Java運算子優先順序 當多個運算子出現在一個表示式中，誰先誰後呢？這就涉及到運算子的優先級別的問題。在一個多運算子的表示式中，運算子優先順序不同會導致最後得出的結果差別甚大。 例如，（1+3）＋（3+2）*2，這個表示式如果按加號最優先計算，答案就是 18，如果按照乘號最優先，答案則是 14。 再如，x = 7 + 3 * 2，這裡x得到13，而不是20，因為乘法運算子比加法運算子有較高的優先順序，所以先計算3 * 2得到6，然後再加7。 下面具有最高優先順序的運算子在最上面，最低優先順序的在底部。 類別 操作符 關聯性 字尾 () [] . (點操作符) 左到右 一元 + + - ！? 從右到左 乘性 * /％ 左到右 加性 + - 左到右 移位 >> >>> << 左到右 關係 >> = << = 左到右 相等 == != 左到右 按位與 ＆ 左到右 按位異或 ^ 左到右 按位或 | 左到右 邏輯與 && 左到右 邏輯或 | | 左到右 條件 ？： 從右到左 賦值 = + = - = * = / =％= >> = << =＆= ^ = | = 從右到左 逗號 ， 左到右 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 迴圈結構 - for, while 及 do…while 。。。。。。 Java 迴圈結構 - for, while 及 do…while 順序結構的程式語句只能被執行一次。如果您想要同樣的操作執行多次,，就需要使用迴圈結構。 Java中有三種主要的迴圈結構：

1. while迴圈

2. do…while迴圈

3. for迴圈 在Java5中引入了一種主要用於陣列的增強型for迴圈。 。。。 while迴圈 while是最基本的迴圈，它的結構為： while( 布林表示式 ) { //迴圈內容 } 只要布林表示式為true，迴圈體會一直執行下去。 。。。 do…while迴圈 對於while語句而言，如果不滿足條件，則不能進入迴圈。但有時候我們需要即使不滿足條件，也至少執行一次。 do…while迴圈和while迴圈相似，不同的是，do…while迴圈至少會執行一次。 do { //程式碼語句 }while(布林表示式); 注意：布林表示式在迴圈體的後面，所以語句塊在檢測布林表示式之前已經執行了。如果布林表示式的值為true，則語句塊一直執行，直到布林表示式的值為false。 。。。 for迴圈 雖然所有迴圈結構都可以用while或者do…while表示，但Java提供了另一種語句 —— for迴圈，使一些迴圈結構變得更加簡單。 for迴圈執行的次數是在執行前就確定的。語法格式如下： for(初始化; 布林表示式; 更新) { //程式碼語句 } 關於for迴圈有以下幾點說明： -最先執行初始化步驟。可以宣告一種型別，但可初始化一個或多個迴圈控制變數，也可以是空語句。 -然後，檢測布林表示式的值。如果為true，迴圈體被執行。如果為false，迴圈終止，開始執行迴圈體後面的語句。 -執行一次迴圈後，更新迴圈控制變數。 -再次檢測布林表示式。迴圈執行上面的過程。 。。。 Java增強for迴圈 Java5引入了一種主要用於陣列的增強型for迴圈。 Java增強for迴圈語法格式如下: for(宣告語句 : 表示式) { //程式碼句子 } 宣告語句：宣告新的區域性變數，該變數的型別必須和陣列元素的型別匹配。其作用域限定在迴圈語句塊，其值與此時陣列元素的值相等。 表示式：表示式是要訪問的陣列名，或者是返回值為陣列的方法。 。。。 break關鍵字 break主要用在迴圈語句或者switch語句中，用來跳出整個語句塊。 break跳出最裡層的迴圈，並且繼續執行該迴圈下面的語句。 語法：break的用法很簡單，就是迴圈結構中的一條語句：break; 。。。 continue關鍵字 continue適用於任何迴圈控制結構中。作用是讓程式立刻跳轉到下一次迴圈的迭代。 在for迴圈中，continue語句使程式立即跳轉到更新語句。 在while或者do…while迴圈中，程式立即跳轉到布林表示式的判斷語句。 語法：continue就是迴圈體中一條簡單的語句：continue; ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java 分支結構 - if…else/switch 。。。。。。 Java 分支結構 - if…else/switch 順序結構只能順序執行，不能進行判斷和選擇，因此需要分支結構。 Java有兩種分支結構：

4. if語句

5. switch語句 。。。 if語句 一個if語句包含一個布林表示式和一條或多條語句。 語法： If語句的用語法如下： if(布林表示式) { //如果布林表示式為true將執行的語句 } 如果布林表示式的值為true，則執行if語句中的程式碼塊。否則執行If語句塊後面的程式碼。 。。。 if…else語句 if語句後面可以跟else語句，當if語句的布林表示式值為false時，else語句塊會被執行。 語法： if…else的用法如下： if(布林表示式){ //如果布林表示式的值為true }else{ //如果布林表示式的值為false } 。。。 if…else if…else語句 if語句後面可以跟else if…else語句，這種語句可以檢測到多種可能的情況。 使用if，else if，else語句的時候，需要注意下面幾點： if語句至多有1個else語句，else語句在所有的else if語句之後。 If語句可以有若干個else if語句，它們必須在else語句之前。 一旦其中一個else if語句檢測為true，其他的else if以及else語句都將跳過執行。 語法： if…else語法格式如下: if(布林表示式 1){ //如果布林表示式 1的值為true執行程式碼 }else if(布林表示式 2){ //如果布林表示式 2的值為true執行程式碼 }else if(布林表示式 3){ //如果布林表示式 3的值為true執行程式碼 }else { //如果以上布林表示式都不為true執行程式碼 } 。。。 巢狀的if…else語句 使用巢狀的if-else語句是合法的。也就是說你可以在另一個if或者else if語句中使用if或者else if語句。 語法： 巢狀的if…else語法格式如下： if(布林表示式 1){ ////如果布林表示式 1的值為true執行程式碼 if(布林表示式 2){ ////如果布林表示式 2的值為true執行程式碼 } } 你可以像 if 語句一樣巢狀 else if…else。 。。。 switch語句 switch語句判斷一個變數與一系列值中某個值是否相等，每個值稱為一個分支。 語法： switch語法格式如下： switch(expression){ case value : //語句 break; //可選 case value : //語句 break; //可選 //你可以有任意數量的case語句 default : //可選 //語句 } switch語句有如下規則： -switch語句中的變數型別只能為byte、short、int或者char。 -switch語句可以擁有多個case語句。每個case後面跟一個要比較的值和冒號。 -case語句中的值的資料型別必須與變數的資料型別相同，而且只能是常量或者字面常量。 -當變數的值與case語句的值相等時，那麼case語句之後的語句開始執行，直到break語句出現才會跳出switch語句。 -當遇到break語句時，switch語句終止。程式跳轉到switch語句後面的語句執行。case語句不必須要包含break語句。如果沒有break語句出現，程式會繼續執行下一條case語句，直到出現break語句。 -switch語句可以包含一個default分支，該分支必須是switch語句的最後一個分支。default在沒有case語句的值和變數值相等的時候執行。default分支不需要break語句。 ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java Number類 一般地，當需要使用數字的時候，我們通常使用內建資料型別，如：byte、int、long、double等。 然而，在實際開發過程中，我們經常會遇到需要使用物件，而不是內建資料型別的情形。為了解決這個問題，Java語言為每一個內建資料型別提供了對應的包裝類。 所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類Number的子類。 這種由編譯器特別支援的包裝稱為裝箱，所以當內建資料型別被當作物件使用的時候，編譯器會把內建型別裝箱為包裝類。相似的，編譯器也可以把一個物件拆箱為內建型別。Number類屬於java.lang包。 。。。 Java Math類 Java 的 Math 包含了用於執行基本數學運算的屬性和方法，如初等指數、對數、平方根和三角函式。 Math 的方法都被定義為 static 形式，通過 Math 類可以在主函式中直接呼叫。 Number & Math 類方法 下面的列出的是常用的Number類和Math類的方法： 序號 方法 描述 1 xxxValue() 將number物件轉換為xxx資料型別的值並返回。 2 compareTo() 將number物件與引數比較。 3 equals() 判斷number物件是否與引數相等。 4 valueOf() 返回一個Integer物件指定的內建資料型別 5 toString() 以字串形式返回值。 6 parseInt() 將字串解析為int型別。 7 abs() 返回引數的絕對值。 8 ceil() 對整形變數向左取整，返回型別為double型。 9 floor() 對整型變數向右取整。返回型別為double型別。 10 rint() 返回與引數最接近的整數。返回型別為double。 11 round() 返回一個最接近的int、long型值。 12 min() 返回兩個引數中的最小值。 13 max() 返回兩個引數中的最大值。 14 exp() 返回自然數底數e的引數次方。 15 log() 返回引數的自然數底數的對數值。 16 pow() 返回第一個引數的第二個引數次方。 17 sqrt() 求引數的算術平方根。 18 sin() 求指定double型別引數的正弦值。 19 cos() 求指定double型別引數的餘弦值。 20 tan() 求指定double型別引數的正切值。 21 asin() 求指定double型別引數的反正弦值。 22 acos() 求指定double型別引數的反餘弦值。 23 atan() 求指定double型別引數的反正切值。 24 atan2() 將笛卡爾座標轉換為極座標，並返回極座標的角度值。 25 toDegrees() 將引數轉化為角度。 26 toRadians() 將角度轉換為弧度。 27 random() 返回一個隨機數。 :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: Java Character類 。。。。。。 Java Character類 使用字元時，我們通常使用的是內建資料型別char。 然而，在實際開發過程中，我們經常會遇到需要使用物件，而不是內建資料型別的情況。為了解決這個問題，Java語言為內建資料型別char提供了包裝類Character類。 Character類提供了一系列方法來操縱字元。你可以使用Character的構造方法建立一個Character類物件，例如：Character ch = new Character(‘a’); 在某些情況下，Java編譯器會自動建立一個Character物件。 例如，將一個char型別的引數傳遞給需要一個Character型別引數時，那麼編譯器會自動地將char型別引數轉換為Character物件。 這種特徵稱為裝箱，反過來稱為拆箱。 。。。 轉義序列 前面有反斜槓（\）的字元代表轉義字元，它對編譯器來說是有特殊含義的。 下面列表展示了Java的轉義序列： 轉義序列 描述 \t