JAVA的關鍵字

1.基本資料型別：

• 整數型別：byte short int long
• 字元型別：char
• 浮點型別：float double
• 布林型：boolean
  

2.類、方法和變數修飾符關鍵字：

1.class類

• class 關鍵字用來宣告新的 Java 類，該類是相關變數和/或方法的集合。
• 類是面向物件的程式設計方法的基本構造單位。類通常代表某種實際實體，如幾何形狀或人。類是物件的模板。每個物件都是類的一個例項。
• 要使用類，通常使用 new 操作符將類的物件例項化，然後呼叫類的方法來訪問類的功能。

2. abstract 宣告抽象

• abstract抽象類或方法聲名。採用abstract方法的類本來就是抽象類，並且必須宣告為abstract。

• abstract類不能例項化。僅當abstract類的子類實現其超類的所有abstract方法時，才能例項化abstract類的子類。這種類稱為具體類，以區別於abstract類。

• 如果abstract類的子類沒有實現其超類的所有abstract方法，該子類也是abstract類。
• abstract關鍵字不能應用於static、private或final方法，因為這些方法不能被重寫，因此，不能在子類中實現。

• final類的方法都不能是abstract，因為final類不能有子類

• 關於抽象類的幾個問題：
  1）抽象類中是否只能定義抽象方法？
  答：不是，含有抽象方法的類一定是抽象類，但是抽象類不一定只有抽象方法，可以含有具體的方法，抽象類是介於介面和普通類之間的一種類。
  2）抽象類中若含有具體的方法，那它是否可以被覆蓋？
  答：可以，它具有類的屬性，方法可以被過載，也可以被預設繼承。

3. extends 繼承、擴充套件

• extends 關鍵字用在 class 或 interface 宣告中，用於指示所宣告的類或介面是其名稱後跟有 extends 關鍵字的類或介面的子類。
• 子類繼承父類的所有 public 和 protected 變數和方法。 子類可以重寫父類的任何非 final 方法。

• 一個類只能擴充套件一個其他類。

• 注：介面與介面之間是可以繼承的，而且可以是多繼承關係，即不存在一個介面只能繼承一個介面的限制。

4. interface 介面

• 注：介面中所有方法應該都沒有具體實現。
• interface 關鍵字用來宣告新的 Java 介面，介面是方法的集合。

• 介面是 Java 語言的一項強大功能。任何類都可宣告它實現一個或多個介面，這意味著它實現了在這些介面中所定義的所有方法。

• 實現了介面的任何類都必須提供在該介面中的所有方法的實現。

• 一個類可以實現多個介面。

5. implements實現

• implements 關鍵字在 class 宣告中使用，以指示所宣告的類提供了在 implements 關鍵字後面的名稱所指定的介面中所宣告的所有方法的實現。

• 類必須提供在介面中所宣告的所有方法的實現。

• 一個類可以實現多個介面。

6. final 最終、不可改變

• final 關鍵字可以應用於類，以指示不能擴充套件該類（不能有子類）。

• final 關鍵字可以應用於方法，以指示在子類中不能重寫此方法。

• 一個類不能同時是 abstract 又是 final。abstract 意味著必須擴充套件類，final 意味著不能擴充套件類。
• 一個方法不能同時是 abstract 又是 final。abstract 意味著必須重寫方法，final 意味著不能重寫方法。

7. static 靜態

• static 關鍵字可以應用於內部類（在另一個類中定義的類）、方法或欄位（類的成員變數）。

• 通常，static 關鍵字意味著應用它的實體在宣告該實體的類的任何特定例項外部可用。

• static（內部）類可以被其他類例項化和引用（即使它是頂級類）。

• static 欄位（類的成員變數）在類的所有例項中只存在一次。

• 可以從類的外部呼叫 static 方法，而不用首先例項化該類。這樣的引用始終包括類名作為方法呼叫的限定符。
• 模式：public final static varName = ; 通常用於宣告可以在類的外部使用的類常量。在引用這樣的類常量時需要用類名加以限定。

8. new 新,建立

• new 關鍵字用於建立類的新例項。

• new 關鍵字後面的引數必須是類名，並且類名的後面必須是一組構造方法引數（必須帶括號）。

• 引數集合必須與類的構造方法的簽名匹配。

• = 左側的變數的型別必須與要例項化的類或介面具有賦值相容關係。

9. synchronized執行緒、同步

• synchronized 關鍵字可以應用於方法或語句塊，併為一次只應由一個執行緒執行的關鍵程式碼段提供保護。

• synchronized 關鍵字可防止程式碼的關鍵程式碼段一次被多個執行緒執行。

• 如果應用於靜態方法，那麼，當該方法一次由一個執行緒執行時，整個類將被鎖定。

• 如果應用於例項方法，那麼，當該方法一次由一個執行緒訪問時，該例項將被鎖定。

• 如果應用於物件或陣列，當關聯的程式碼塊一次由一個執行緒執行時，物件或陣列將被鎖定。

10. native 本地

• native 關鍵字可以應用於方法，以指示該方法是用 Java 以外的語言實現的。

11. strictfp 嚴格,精準的浮點型

• strictfp的意思是FP-strict，也就是說精確浮點的意思。在Java虛擬機器進行浮點運算時，如果沒有指定strictfp關鍵字時，Java的編譯器以及執行環境在對浮點運算的表示式是採取一種近似於我行我素的行為來完成這些操作，以致於得到的結果往往無法令人滿意。而一旦使用了strictfp來宣告一個類、介面或者方法時，那麼所宣告的範圍內Java的編譯器以及執行環境會完全依照浮點規範IEEE-754來執行。因此如果想讓浮點運算更加精確，而且不會因為不同的硬體平臺所執行的結果不一致的話，那就請用關鍵字strictfp。

• 可以將一個類、介面以及方法宣告為strictfp，但是不允許對介面中的方法以及建構函式宣告strictfp關鍵字

12. transient 短暫

• transient 關鍵字可以應用於類的成員變數，以便指出該成員變數不應在包含它的類例項已序列化時被序列化。

• 當一個物件被序列化的時候，transient型變數的值不包括在序列化的表示中，然而非transient型的變數是被包括進去的。

• Java的serialization提供了一種持久化物件例項的機制。當持久化物件時，可能有一個特殊的物件資料成員，我們不想用serialization機制來儲存它。為了在一個特定物件的一個域上關閉serialization，可以在這個域前加上關鍵字transient。

• transient是Java語言的關鍵字，用來表示一個域不是該物件序列化的一部分。當一個物件被序列化的時候，transient型變數的值不包括在序列化的表示中，然而非transient型的變數是被包括進去的。

13.volatile 易失

• volatile 關鍵字用於表示可以被多個執行緒非同步修改的成員變數。

• 注意：volatile 關鍵字在許多 Java 虛擬機器中都沒有實現。 volatile 的目標用途是為了確保所有執行緒所看到的指定變數的值都是相同的。

• Java 語言中的 volatile 變數可以被看作是一種 ”程度較輕的 synchronized“；與 synchronized 塊相比，volatile 變數所需的編碼較少，並且執行時開銷也較少，但是它所能實現的功能也僅是 synchronized 的一部分。
  注：後面四個不是很常用。

3．訪問修飾符關鍵字

1.public：所修飾的類、方法和變數是公共的，其他類可以訪問該關鍵字修飾的類、方法或者變數。
2.protected：用於修飾方法和變數。這些方法和變數可以被同一個包中的類或者子類以及不同包的子類進行訪問。
3.private：同樣修飾方法和變數。方法和變數只能由所在類進行訪問。
4.default：不標註的預設許可權，這些方法和變數可以被同一個包中的類或者子類進行訪問。

4．流程控制關鍵字

1. break 跳出，中斷

• break 關鍵字用於提前退出 for、while 或 do 迴圈，或者在 switch 語句中用來結束 case 塊。

• break 總是退出最深層的 while、for、do 或 switch 語句。

2. continue 繼續

• continue 關鍵字用來跳轉到 for、while 或 do 迴圈的下一個迭代。

• continue 總是跳到最深層 while、for 或 do 語句的下一個迭代。

注意：break與continue的區別：break是結束整個迴圈體，continue是結束單次迴圈。

/**
*比較break和continue
*/
public class Different {

    public static void main(String[] args) {
        testBreak();
        System.out.println();
        testContinue();
    }
    //迴圈列印1-10，但是如果i=3，則呼叫break
    public static void testBreak(){
        int i=0;
        while( ++i<=10){
            if(3==i){
                break;
            }else{
                System.out.print(i+" ");
             }
        }
    }
    //迴圈列印1-10，當j=3，呼叫continue
    public static void testContinue(){
        int j=0;
        while(++j<=10){
            if(3==j){
                continue;
            }else{
                System.out.print(j+" ");
             }
        }
    }
}

執行結果：

可見，break跳出了整個迴圈；而continue只是跳出了當前迴圈，進入下一次迴圈。

3. return 返回

• return 關鍵字會導致方法返回到呼叫它的方法，從而傳遞與返回方法的返回型別匹配的值。

• 如果方法具有非 void 的返回型別，return 語句必須具有相同或相容型別的引數。

• 返回值兩側的括號是可選的。

4. do 執行

• do 關鍵字用於指定一個在每次迭代結束時檢查其條件的迴圈。

• do 迴圈體至少執行一次。

• 條件表示式後面必須有分號。

5. while 迴圈

• while 關鍵字用於指定一個只要條件為真就會重複的迴圈。

6. if 如果

• if 關鍵字指示有條件地執行程式碼塊。條件的計算結果必須是布林值。

• if 語句可以有可選的 else 子句，該子句包含條件為 false 時將執行的程式碼。

• 包含 boolean 運算元的表示式只能包含 boolean 運算元。

7. else 否則

• else 關鍵字總是在 if-else 語句中與 if 關鍵字結合使用。else 子句是可選的，如果 if 條件為 false，則執行該子句。

8. for 迴圈

• for 關鍵字用於指定一個在每次迭代結束前檢查其條件的迴圈。

• for 語句的形式為 for(initialize; condition; increment)

  • 控制元件流進入 for 語句時，將執行一次 initialize 語句。

  • 每次執行迴圈體之前將計算 condition 的結果。如果 condition 為 true，則執行迴圈體。

  • 每次執行迴圈體之後，在計算下一個迭代的 condition 之前，將執行 increment 語句。

9. instanceof 例項

• instanceof 關鍵字用來確定物件所屬的類。

10. switch 觀察

• switch 語句用於基於某個表示式選擇執行多個程式碼塊中的某一個。

• switch 條件的計算結果必須等於 byte、char、short 或 int。

• case 塊沒有隱式結束點。break 語句通常在每個 case 塊末尾使用，用於退出 switch 語句。

• 如果沒有 break 語句，執行流將進入所有後面的 case 和/或 default 塊。

11. case 返回觀察裡的結果

• case 用來標記 switch 語句中的每個分支。

• case 塊沒有隱式結束點。break 語句通常在每個 case 塊末尾使用，用於退出 switch 語句。

• 如果沒有 break 語句，執行流將進入所有後面的 case 和/或 default 塊。

12. default 預設

• default 關鍵字用來標記 switch 語句中的預設分支。

• default 塊沒有隱式結束點。break 語句通常在每個 case 或 default 塊的末尾使用，以便在完成塊時退出 switch 語句。

• 如果沒有 default 語句，其引數與任何 case 塊都不匹配的 switch 語句將不執行任何操作。

5. 錯誤處理

1. try 捕獲異常

• try 關鍵字用於包含可能引發異常的語句塊。

• 每個 try 塊都必須至少有一個 catch 或 finally 子句。

• 如果某個特定異常類未被任何 catch 子句處理，該異常將沿著呼叫棧遞迴地傳播到下一個封閉 try 塊。如果任何封閉 try 塊都未捕獲到異常，Java 直譯器將退出，並顯示錯誤訊息和堆疊跟蹤資訊。

2. catch 處理異常

• catch 關鍵字用來在 try-catch 或 try-catch-finally 語句中定義異常處理塊。

• 開始和結束標記 { 和 } 是 catch 子句語法的一部分，即使該子句只包含一個語句，也不能省略這兩個標記。

3. throw 丟擲一個異常物件

• throw 關鍵字用於引發異常。

• throw 語句將 java.lang.Throwable 作為引數。Throwable 在呼叫棧中向上傳播，直到被適當的 catch 塊捕獲。

4. throws 宣告一個異常可能被丟擲

• throws 關鍵字可以應用於方法，以便指出方法引發了特定型別的異常。

• throws 關鍵字將逗號分隔的 java.lang.Throwables 列表作為引數。

• 引發非 RuntimeException 異常的任何方法還必須在方法宣告中使用 throws 修飾符來宣告它引發的異常。

• 要在 try-catch 塊中包含帶 throws 子句的方法的呼叫，必須提供該方法的呼叫者。

注：throws與throw有什麼不同？
throw：在java程式碼中如果發生異常的話，jvm會丟擲異常物件，導致程式程式碼中斷，這個時候jvm在做的操作就是：建立異常物件，然後丟擲。但是有時候有些錯誤在jvm看來不是錯誤，所以我們需要自己手動引發異常，這就是throw的作用，用來讓我們手動丟擲一個異常。

throws：宣告方法可能迴避的異常。
有異常被丟擲了，就要做處理，所以java中有try-catch，可是有時候一個方法中產生了異常，但是不知道該怎麼處理它，那麼就放著不管，當有異常丟擲時會中斷該方法，而異常被拋到這個方法的呼叫者那裡。這個有點像下屬處理不了的問題就交到上司手裡一樣，這種情況稱為迴避異常。但是這使得呼叫這個方法就有了危險，因為誰也不知道這個方法什麼時候會丟一個什麼樣的異常給呼叫者，所以在定義方法時，就需要在方法頭部分使用throws來宣告這個方法可能迴避的異常。

6. 包相關

1. import 引入

• import 關鍵字使一個包中的一個或所有類在當前 Java 原始檔中可見。可以不使用完全限定的類名來引用匯入的類。

• 當多個包包含同名的類時，許多 Java 程式設計師只使用特定的 import 語句（沒有“*”）來避免不確定性。

注：即含有同名類的不同包需要同時被引用時，就不要使用import關鍵字了，直接在引用處指出具體路徑，以免混淆使用。
例如，同時使用類java.awt.List和介面java.util.List時，就不能在使用import關鍵字了，因為不能識別你用的是哪個List,所以需要在使用時引用路徑；
java.util.List list=new ArrayList();

2. package 包

• package 關鍵字指定在 Java 原始檔中宣告的類所駐留的 Java 包。

• package 語句（如果出現）必須是 Java 原始檔中的第一個非註釋性文字。 例:java.lang.Object。

• 如果 Java 原始檔不包含 package 語句，在該檔案中定義的類將位於“預設包”中。請注意，不能從非預設包中的類引用預設包中的類。

7. 變數引用

1. super 父類,超類

• super 關鍵字用於引用使用該關鍵字的類的超類。

• 作為獨立語句出現的 super 表示呼叫超類的構造方法。

• super.() 表示呼叫超類的方法。只有在如下情況中才需要採用這種用法：要呼叫在該類中被重寫的方法，以便指定應當呼叫在超類中的該方法。

2. this 本類

• this 關鍵字用於引用當前例項。

• 當引用可能不明確時，可以使用 this 關鍵字來引用當前的例項。

3. void 無返回值

• void 關鍵字表示 null 型別。

• void 可以用作方法的返回型別，以指示該方法不返回值。

8. 保留字

正確識別java語言的關鍵字（keyword）和保留字（reserved word）是十分重要的。Java的關鍵字對java的編譯器有特殊的意義，他們用來表示一種資料型別，或者表示程式的結構等。保留字是為java預留的關鍵字，他們雖然現在沒有作為關鍵字，但在以後的升級版本中有可能作為關鍵字。

識別java語言的關鍵字，不要和其他語言如c/c++的關鍵字混淆。
const和goto是java的保留字。 所有的關鍵字都是小寫
1. goto 跳轉

• goto 保留關鍵字，但無任何作用。結構化程式設計完全不需要 goto 語句即可完成各種流程，而 goto 語句的使用往往會使程式的可讀性降低，所以 Java 不允許 goto 跳轉。

2. const 靜態

• const 保留字，是一個型別修飾符，使用const宣告的物件不能更新。與final某些類似。

3. native 本地

• Java不是完美的，Java的不足除了體現在執行速度上要比傳統的C++慢許多之外，Java無法直接訪問到作業系統底層（如系統硬體等)，為此Java使用native方法來擴充套件Java程式的功能。

  　　可以將native方法比作Java程式同Ｃ程式的介面，其實現步驟：

  　　１、在Java中宣告native()方法，然後編譯；

  　　２、用javah產生一個.h檔案；

  　　３、寫一個.cpp檔案實現native匯出方法，其中需要包含第二步產生的.h檔案（注意其中又包含了JDK帶的jni.h檔案）；

  　　４、將第三步的.cpp檔案編譯成動態連結庫檔案；

  　　５、在Java中用System.loadLibrary()方法載入第四步產生的動態連結庫檔案，這個native()方法就可以在Java中被訪問了。