關鍵字
（50個，包含2個保留字）和特殊值(3個)
一、基本資料類型相關關鍵字(8個)
1、關鍵字介紹（1）byte：單位元組類型（2）short：短整型（3）int：整型（4）long：長整型（5）char：單字元類型（6）float：單精度浮點型（7）double：雙精度浮點型（8）boolean：布爾類型
2、基本資料類型之間的轉換規則（順帶整理）
二、聲明引用資料類型相關(3個)
（9）class：聲明類（10）interface：聲明接口（11）enum：聲明枚舉
三、特殊空類型（1個）
（12）void：無傳回值類型
四、流程控制語句相關（10個）
（13）if：條件判斷分支結構（14）else：條件判斷分支結構（15）switch：選擇結構（16）case：選擇結構（17）for：循環（18）while：循環（19）do（20）break（21）continue （22）return
五、default（1個）
（23）default：預設的
六、關系（5個）
（24）extends：繼承關系（25）implements：實作關系（26）instanceof：所屬關系判斷（27）this：引用目前對象的（28）super：引用父類的
七、建立對象（1個）
（29）new：建立
八、和包相關（2個）
（30）package：聲明包（31）import：導包
九、修飾符
1、權限修飾符（3個）（32）private：私有的（33）protected：受保護的（34）public：公共的
2、其他修飾符（8個）（35）static：靜态的（36）native：原生的（37）final：最終的（38）abstract：抽象的（39）synchronized：同步的（40）volatile：易變的（41）strictfp：嚴格遵循FP模式（42）transient：瞬時的
十、和異常處理相關的（5個）
（43）try：嘗試執行（44）catch：嘗試捕獲異常對象（45）finally：最終塊（46）throw：抛出（47）throws：抛出異常清單
十一、assert（1個）
（48）assert：斷言
十二、保留字（2個）
（49）const：常數，不變的（50）goto：跳轉
十三、特殊值（3個）
（51）true：真（52）false：假（53）null：空，如果null調用屬性和方法會報空指針異常
關鍵字一共50個，其中const和goto是保留字。
true,false,null看起來像關鍵字，但從技術角度，它們是特殊的布爾值和空值。
1、關鍵字介紹
（1）byte：單位元組類型
1個位元組（8位），資料範圍：[-128,127]
注意：byte類型與byte類型做算術運算結果更新為int
（2）short：短整型
2個位元組（16位），資料範圍：[-32768,32767]
注意：short類型與short類型做算術運算結果更新為int
（3）int：整型
4個位元組（32位），資料範圍：[-2的31次方 , 2的31次方 -1]
（4）long：長整型
8個位元組（64位），資料範圍：[-2的63次方 , 2的63次方 -1]
注意：long類型的數字後面需要加L或小寫l
（5）char：單字元類型
2個位元組（16位），無符号整數範圍：[0,65535]，使用Unicode字元集
其中标準ASCII字元集：[0,127]，數字字元['0','9']的編碼值是[48,57]，大寫字母字元['A','Z']的編碼值是[65,90]，小寫字母字元['a','z']的編碼值是[97,122]。
char類型的字元常量有三種表示方式：
（1）'a'、'尚'
（2）轉義字元：
（3）使用Unicode編碼值十六進制形式表示
例如：'\u5c1a' 表示 '尚'
注意：char類型與char類型做算術運算結果是int類型
（6）float：單精度浮點型
4個位元組，表示最大精度範圍：科學記數法表示數字後的小數點後6~7位
注意：float類型的數字後面需要加F或f
（7）double：雙精度浮點型
8個位元組，表示最大精度範圍：科學記數法表示數字後的小數點後15~16位
（8）boolean：布爾類型
它隻能有兩個值：true和false
2、基本資料類型之間的轉換規則
1、自動類型轉換
①當存儲範圍小的資料(變量/表達式/常量)，指派給存儲範圍大的變量時，自動更新為該存儲範圍大的類型
char
byte->short->int->long->float->double
②當byte與byte,short與short，char與char，byte,short,char之間一起運算了，都會自動更新為int
③當多種基本資料類型的資料一起混合運算，會自動更新為它們中最大的類型
④當基本資料類型的資料 與 String類型進行“+”拼接時，結果自動轉為String類型。
⑤boolean類型不和其他基本資料類型發生轉換
2、強制類型轉換
①當存儲範圍大的資料（變量、表達式、常量）指派給存儲範圍小的變量時，都是需要強制類型轉換
double->float->long->int->short->byte
char
注意：可能會溢出，或者損失精度
②當某個資料（變量、表達式、常量）想要讓它按照某個大的類型進行計算時，也可以使用強制類型轉換
③boolean和String都是無法通過強制類型轉換為基本資料類型的值。
（9）class：聲明類
文法格式：
【修飾符】 class 類名{
...
}
【修飾符】 class 類名 【extends 父類】 【implements 父接口們】{
...
} 類中可以有5個成員：
（1）成員變量：屬性
（2）成員方法
（3）構造器
（4）代碼塊
（5）成員内部類
（10）interface：聲明接口
【修飾符】 interface 接口名{
...
}
【修飾符】 interface 接口名 【extends 父接口們】{
...
} 接口的特點：
（1）接口對成員有嚴格的要求：
在JDK1.8之前，接口隻能有全局的靜态的常量(public static final)和公共的抽象方法(public abstract)；
在JDK1.8之後，接口中可以有公共的靜态方法（public static）和公共的預設方法（public default）；
接口沒有構造器、代碼塊能、其他成員，但是接口中可以聲明成員内部類、成員内部接口。
（2）接口不能直接執行個體化，但是接口類型的變量可以與其實作類的對象之間構成多态引用
（3）接口可以繼承多個父接口
（4）Java類可以同時實作多個父接口，實作類實作接口時，如果實作類不是抽象類，必須實作接口的所有抽象方法。
（11）enum：聲明枚舉
【修飾符】 enum 枚舉類型名{
...
}
【修飾符】 enum 枚舉類型名 【implements 父接口們】{
...
} 枚舉類型的特點：
（1）枚舉類型有已知的幾個常量對象，必須在枚舉類型的首行聲明；
（2）枚舉類型不能顯式聲明父類，因為它預設繼承java.lang.Enum類型
（12）void：無傳回值類型
//抽象方法
【修飾符】 void 方法名（【形參清單】）【throws 異常清單】;
//非抽象方法
【修飾符】 void 方法名（【形參清單】）【throws 異常清單】{
} 注意：如果在傳回值類型是void的方法，想要提前結束方法運作，可以使用return;
（13）if：條件判斷分支結構
（14）else：條件判斷分支結構
#單分支條件判斷
if(條件表達式){
語句塊;
}
#雙分支條件判斷
if(條件表達式){
語句塊1;
}else{
語句塊2;
}
#多分支條件判斷
if(條件表達式1){
語句塊1;
}else if(條件表達式2){
語句塊2;
}else if(條件表達式3){
語句塊3;
}
...
else{
語句塊n+1;
} （15）switch：選擇結構
（16）case：選擇結構
switch(表達式){
case 常量值1:
語句塊1;
【break;】
case 常量值2:
語句塊2;
【break;】
...
【default:
語句塊n+1;
【break;】
】
} 執行過程：
（1）入口
①當switch(表達式)中表達式的值與case後面的某個常量值比對了，就從這個case進入；
②當switch(表達式)中表達式的值與所有case後面的常量值都不比對，就從default進入，不管default部分在哪裡。
（2）一旦找到入口，就會順序往下執行，直到遇到出口
（3）出口
①自然出口：switch的結束}
②中斷出口：break;
注意：
①switch(表達式)中表達式的結果的類型有要求：四種基本資料類型(byte,short,int,char)和兩種引用資料類型(JDK1.7後支援String，JDK1.5後支援枚舉)
②case後面必須是常量值或常量表達式，絕對不能是變量
③case後面的常量值不能重複
（17）for：循環
1、普通for循環
for(【初始化表達式】; 【循環條件】; 【疊代表達式】){
循環體語句塊；
} （1）先執行【初始化表達式】
（2）判斷【循環條件】
（3）如果【循環條件】成立，就執行{循環體語句塊；}，之後執行【疊代表達式】，然後回到（2）
如果【循環條件】不成立，就直接結束for循環
（1）for(;;)兩個分号不能省略，但也不能多了
（2）如果for(;;)中間的循環條件沒寫，就是表示條件永遠成立，如果{}中沒有break，return等就會死循環
2、增強for循環
for(元素資料類型 元素名 : 數組或集合等容器名){
循環體語句塊;
} 說明：
（1）常用于周遊數組和集合等容器，其實隻要是實作了java.lang.Iterable接口的容器對象都可以使用foreach來進行周遊，其實調用的是java.util.Iterator疊代器的hasNext()和next()方法
（2）在使用foreach周遊集合時，不要同時調用集合涉及到修改元素個數的方法
錯誤示例：
ArrayList list = new ArrayList();
for(Object obj : list){
list.add(xx);//錯誤
list.remove(xx);//錯誤
} （18）while：循環
while(循環條件){
循環體語句塊;
} （1）先判斷循環條件
（2）如果條件成立，執行{循環體語句塊;}，然後回到（1）
如果條件不成立，直接結束while循環。
（19）do
do{
循環體語句塊;
}while(循環條件); （1）先上來就執行一次{循環體語句塊;} 說明do...while系列的循環，至少執行一次循環體語句塊;
（2）判斷循環條件
（3）如果條件成立，再次執行{循環體語句塊;} ，然後回到（2）
如果條件不成立，那麼直接結束do..while
（1）do...while系列的循環，至少執行一次循環體語句塊;
（2）while(循環條件); 後面的;不能省略
（3）如果是在{循環體語句塊;}中聲明的局部變量，是不能在while()中使用的，如果要在while()中使用這個變量，那麼需要提取到do{}上面聲明；
（20）break
用法：
（1）switch：結束目前switch
（2）循環：結束目前（層）循環
如果break在内循環中，隻能結束内循環；
如果break在外循環中内循環外，可以結束外循環;
如果break結合标簽，那麼可以直接結束标簽對應的循環;
（21）continue
隻能用在循環中：提前結束本次循環，跳過了本次循環剩下的循環體語句
（22）return
形式：
（1）return ;
用于提前結束傳回值類型是void的方法。
可選：傳回值類型為void方法中，可能有return;，也可能沒有;
（2）return 傳回值;
用于提前結束傳回值類型不是void的方法，并且會傳回結果。
必選：傳回值類型不是void的方法中，必須有return 傳回值;語句
（23）default：預設的
1、switch...case流程控制語句結構中
2、JDK1.8之後接口中用于聲明預設方法
3、在注解中用于聲明某個配置參數的預設值
（24）extends：繼承關系
【修飾符】 class 子類 extends 父類{
}
【修飾符】 interface 子接口 extends 父接口{
} （25）implements：實作關系
【修飾符】 class 子類 【extends 父類】 implements 接口們{
} （26）instanceof：所屬關系判斷
if(對象 instanceof 類型名){
}
隻有這個對象屬于這個類型，就傳回true 提示：一般用于在向下轉型之前，加這個判斷可以避免ClassCastException異常
（27）this：引用目前對象
this關鍵字：目前對象（1）在構造器或非靜态代碼塊中，表示正在建立的對象（2）在成員方法中，表示正在調用目前方法的對象
this的用法：（1）this.屬性 或 this.成員變量當局部變量與成員變量重名時，那麼可以在成員變量的前面加this.進行區分
this.屬性，如果在本類中沒有找到，也可能表示引用從父類繼承到子類中可見的屬性
（2）this.成員方法()可以省略this.，表示通路目前對象的其他成員方法
this.方法，如果在本類中沒有找到，也可能表示引用從父類繼承到子類中可見的方法
（3）this()或this(實參清單)當需要調用本類的其他構造器，可以在目前構造器的首行用this()或this(實參清單)進行調用
this()和this(實參清單)隻會在本類中查找
（28）super：引用父類
super關鍵字：引用父類的，找父類的xx
super的用法：
1、super.屬性
如果子類聲明了一個屬性，它和從父類繼承的屬性同名了，這個時候從父類繼承的屬性會被hidng(隐藏)，如果此時在子類中想要使用它，那麼就要用super.屬性。
super.屬性也是通路不了父類的私有的屬性，如果跨包，super.屬性也通路不了父類權限修飾符預設的屬性
super.屬性，如果在直接父類中沒有找到，還會向上往間接父類繼續查找
2、super.方法
如果子類重寫了從父類繼承的某個方法後，在子類中又想要調用父類被重寫的方法時，那麼就可以使用super.方法
父類私有的方法是不能被重寫的，父類私有的方法通過super.方法也是無法通路的
如果跨包，父類權限修飾符預設的方法也不能被重寫和通過super.方法通路到
super.方法，如果在直接父類中沒有找到，還會向上往間接父類繼續查找
3、super()或super(實參清單)
在子類的構造器的首行，
通過super()調用父類的無參構造器，super()這個可以省略。
通過super(實參清單)調用父類的有參構造，super(實參清單)不能省略。
注意：super()和super(實參清單)隻能從直接父類找，不能跨過直接父類去引用間接父類的
（29）new：建立
用于建立數組對象、類的對象
建立的對象會存儲在堆中。
八、和包相關的（2個）
（30）package：聲明包
1、包的作用：（1）避免類的重名（2）控制某些類、成員的可見範圍（3）分包進行組織管理衆多的類
2、聲明包的文法格式：
package 包名; 注意：package語句必須在.java源檔案的首行
3、包的命名規範和習慣：（1）所有單詞都小寫，每個單詞之間使用.分割（2）習慣用公司域名倒置 + 子產品名
（31）import：導包
4、使用其他包的類：（1）使用全名稱：包.類名（2）使用import語句 + 簡名稱
5、import語句
import 包.類名;
import 包.*;
import static 包.類名.靜态成員名;
import static 包.類名.*; 注意：當使用兩個不同包的同名類時，例如：java.util.Date和java.sql.Date，隻能一個使用全名稱，一個使用導包。
1、權限修飾符（3個）
（32）private：私有的
（33）protected：受保護的
（34）public：公共的
| 權限修飾符 | 本類 | 本包中其他類 | 其他包的子類 | 其他包的非子類（任意位置） | 可以修飾 |
|---|---|---|---|---|---|
| private | √ | × | 屬性、方法、構造器、成員内部類 | ||
| 預設 | 屬性、方法、構造器、成員内部類、外部類 | ||||
| protected | |||||
| public |
2、其他修飾符（8個）
（35）static：靜态的
static：靜态的，可以修飾成員變量、成員方法、代碼塊、成員内部類
static隻能修飾内部類，不能修飾頂級類
static是一個修飾符，可以修飾：
- 成員變量，我們稱為類變量，或靜态變量，表示某個類的所有對象共享的資料
- 成員方法，我們稱為類方法，或靜态方法，表示不需要執行個體對象就可以調用的方法。類名.
- 代碼塊，我們稱為靜态代碼塊，或靜态初始化塊，用于為靜态變量初始化，每一個類的靜态代碼塊隻會執行一次，在類第一次初始化時執行
- 成員内部類，我們稱為靜态成員内部類，簡稱靜态内部類，不需要外部類執行個體對象就可以使用的内部類，在靜态内部類中隻能使用外部類的靜态成員
（1）成員變量，屬性：static修飾的成員變量稱為“類變量，或靜态變量”，
它的值是該類所有對象的共享的，存儲在方法區，
它的get/set方法也是靜态的，如果在靜态方法中，類變量與局部變量重名時，使用“類名.”進行差別。
（2）成員方法：static修飾的成員方法稱為“類方法，或靜态方法”，它不能被重寫，可以被繼承，
調用它可以用“類名.”進行調用，
在靜态方法中，不能出現this,super,不能直接使用本類的非靜态的屬性、非靜态的方法、非靜态的成員内部類。
（3）代碼塊：static修飾的代碼塊稱為“靜态代碼塊”，它是在類初始化時執行，因為它的代碼會被編譯器合并到<clinit>()類初始化方法中，它隻執行一次，子類的初始化時，如果發現父類沒有初始化，會先初始化父類。
（4）成員内部類
static修飾的成員内部類稱為“靜态内部類”，
靜态内部類中可以包含靜态成員；
靜态内部類在外部類外面使用時，使用“外部類名.靜态内部類"即可。
【修飾符】 class 類{
【修飾符】 static 資料類型 靜态變量;
static{
靜态代碼塊;
}
【修飾符】 static 傳回值類型 方法名(【形參清單】)【throws 異常清單】{
}
【修飾符】 static class 靜态内部類{
}
} （36）native：原生的
native：本地的，原生的隻能修飾方法，表示這個方法的方法體不是用Java語言實作的，但是可以和普通的Java方法一樣去調用和重寫它。
（37）final：最終的
final：最終的，可以修飾類、方法、變量（1）類（包括外部類、内部類）：表示不能被繼承
（2）方法：不能被子類重寫，可以被繼承
（3）變量（包括成員變量和局部變量）：值不能修改，即為常量建議常量名大寫，每個單詞之間使用_分割，形式：XXX_YYY_ZZZ
如果變量是引用類型，變量位址值不可改變但指向的值可以改變，例如數組變量arr位址值不可變，但arr[0]元素值可以改變
（38）abstract：抽象的
abstract：抽象的，隻能修飾類、方法
（1）方法：
abstract修飾的方法稱為“抽象方法”
【權限修飾符】 abstract class 抽象類{
【修飾符】 abstract 傳回值類型 方法名(【形參清單】)【throws 異常清單】;
}
【權限修飾符】 interface 接口名{
public abstract 傳回值類型 方法名(【形參清單】)【throws 異常清單】;
} 特點：
抽象方法沒有方法體，
包含抽象方法的類必須是抽象類，
子類繼承抽象類或實作類實作接口時，如果該子類或實作類不是抽象類，那麼必須實作抽象父類和接口的所有抽象方法。
（2）類：
abstract修飾的類稱為“抽象類”。
【權限修飾符】 abstract class 抽象類{
}
【權限修飾符】 abstract class 抽象類 【extends 父類】 【implements 父接口們】{
} （1）擁有一個或者多個抽象方法的類“必須”是抽象類
（2）抽象類不能直接建立對象，即不能執行個體化，但是抽象類的變量可以與子類的對象構成多态引用。
（3）有時抽象類中沒有抽象方法，（目的隻有一個：不讓你建立對象）
（4）抽象類就是用來被繼承的，子類繼承抽象類時，必須對父類的抽象方法進行實作，否則子類也得是抽象類
（5）抽象類也是類，是以原來類中可以有的5大成員，抽象類都可以有
（39）synchronized：同步的
synchronized：同步的，可以修飾方法和同步代碼塊
（1）同步方法
【修飾符】 synchronized 傳回值類型 方法名(【形參清單】)【throws 異常清單】{
...
} 同步方法的鎖對象：
靜态方法：目前類.class
非靜态方法：this
（2）同步代碼塊
synchronized(鎖對象){
} （40）volatile：易變的
volatile：易變的，不定性的，可以修飾成員變量
表示該成員變量的值是易變的，每一次擷取它的值都要從主存中重新讀取，以保證在多線程中，不同線程讀取到的該值都是最新的。
因為Java中多線程讀取某個成員變量時，發現一段時間内它的值都未發生變化，Java執行引擎就會把這個值放在緩存中，以後的線程讀取，就會讀取這個緩存值，即使這個時候某個線程修改了該變量主存中的值，Java執行引擎仍然會去讀取緩存的值，而如果希望線程總是讀取最新的該變量的值，那麼可以在變量前面加volatile，使得Java執行引擎都從主存中讀取，而不緩存。
（41）strictfp：嚴格遵循FP模式
strictfp：表示要求嚴格遵循FP模式，可以修飾類、接口、方法
使用 strictfp 關鍵字聲明一個方法時，該方法中所有的float和double表達式都嚴格遵守FP-strict的限制,符合IEEE-754規範。
當對一個類或接口使用 strictfp 關鍵字時，該類中的所有代碼，包括嵌套類型中的初始設定值和代碼，都将嚴格地進行計算。嚴格限制意味着所有表達式的結果都必須是 IEEE 754 算法對操作數預期的結果，以單精度和雙精度格式表示。如果你想讓你的浮點運算更加精确，而且不會因為不同的硬體平台所執行的結果不一緻的話，可以用關鍵字strictfp。
（42）transient：瞬時的
transient：表示瞬時的，臨時的，短暫的，轉瞬即逝的;
用于修飾成員變量；
transient修飾的成員變量的值，如果該類實作的是java.io.Serializable接口，那麼在序列化過程中該成員變量不會參與序列化。
修飾符一起使用問題
| 修飾符 | 外部類 | 成員變量 | 代碼塊 | 構造器 | 方法 | 局部變量 |
|---|---|---|---|---|---|---|
| static | ||||||
| final | ||||||
| abstract | ||||||
| native |
不能和abstract一起使用的修飾符？
（1）abstract和final不能一起修飾方法和類
（2）abstract和static不能一起修飾方法
（3）abstract和native不能一起修飾方法
（4）abstract和private不能一起修飾方法
static和final一起使用：
（1）修飾方法：可以，因為都不能被重寫
（2）修飾成員變量：可以，表示靜态常量
（3）修飾局部變量：不可以，static不能修飾局部變量
（4）修飾代碼塊：不可以，final不能修飾代碼塊
（5）修飾内部類：可以一起修飾成員内部類，不能一起修飾局部内部類
（43）try：嘗試執行
（44）catch：嘗試捕獲異常對象
（45）finally：最終塊
//形式1：
try{
語句塊;
}catch(異常類型1 異常對象名1){
處理異常代碼塊1;
}catch(異常類型1 異常對象名1){
處理異常代碼塊1;
}
...
//形式2：
try{
語句塊;
}catch(異常類型1 異常對象名1){
處理異常代碼塊1;
}catch(異常類型1 異常對象名1){
處理異常代碼塊1;
}
...
finally{
最終語句塊;
}
//形式3：
try{
語句塊;
}finally{
最終語句塊;
}
try：嘗試執行某些代碼，如果發生異常，将會抛出異常對象，讓catch去捕獲；
catch：嘗試捕獲try中抛出的異常對象，如果類型比對，就可以捕獲，目前方法不會結束；如果所有catch都無法捕獲，将會結束目前方法。
finally：無論try中是否有異常抛出，也無論是否catch捕獲了該異常，也無論try和catch中是否有return語句都會執行。
JDK1.7之後引入新try..catch
try(需要關閉的資源對象的聲明){
業務邏輯代碼
}catch(異常類型 e){
處理異常代碼
}catch(異常類型 e){
處理異常代碼
}
.... 它沒有finally，也不需要程式員去關閉資源對象，無論是否發生異常，都會關閉資源對象
（46）throw：抛出
用于手動抛出異常
throw 異常對象; throw可以用于抛出異常對象，如果它抛出的異常，沒有被catch的話，可以代替return語句結束目前方法，并将把異常對象帶回調用處。
使用者自定義異常隻能使用throw語句手動抛出。
（47）throws：抛出異常清單
用于在方法簽名中，聲明該方法将抛出哪些類型的異常。
【修飾符】 傳回值類型 方法名(【形參清單】) throws 異常類型清單{
} 表示這些異常在目前方法中沒有處理，交給調用者進行處理。
（48）assert：斷言
如果它斷言的表達式為false，将會抛出java.lang.AssertionError對象。
assert 布爾表達式;
或
assert 布爾表達式 : "錯誤資訊"; 注意：要開啟斷言功能，在eclipse中需要加JVM參數 -ea
（49）const：常數，不變的
在C語言等其他很多程式設計語言中用于聲明常量。在Java中沒有使用它。
（50）goto：跳轉
在C語言等其他很多程式設計語言中用于跳轉到指定位置。在Java中沒有使用它。
（51）true：真
（52）false：假
boolean值，通常用來作為條件。
boolean類型的變量，比較表達式（>,<,>=,<=,==,!=），邏輯表達式（&&,&,||,|,^,!），instanceof，這些都是boolean值。
（53）null：空，如果null調用屬性和方法會報空指針異常
這三個看似關鍵字，但是從技術角度來說，不能算是關鍵字，是特殊值。