（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）byte：單字節類型
注意：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都是無法通過強制類型轉換為基本數據類型的值。
二、聲明引用數據類型相關(3個)
（9）class：聲明類
語法格式：
【修飾符】 class 類名{
...
}
【修飾符】 class 類名 【extends 父類】 【implements 父接口們】{
...
}
類中可以有5個成員：
（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;
四、流程控制語句相關（10個）
（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：選擇結構
語法格式：
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后面的常量值不能重復
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 返回值;語句
用法：
1、switch...case流程控制語句結構中
2、JDK1.8之后接口中用於聲明默認方法
3、在注解中用於聲明某個配置參數的默認值
六、關系（5個）
（24）extends：繼承關系
【修飾符】 class 子類 extends 父類{
}
【修飾符】 interface 子接口 extends 父接口{
}
（25）implements：實現關系
語法格式：
【修飾符】 class 子類 【extends 父類】 implements 接口們{
}
（26）instanceof：所屬關系判斷
語法格式：
if(對象 instanceof 類型名){
}
只有這個對象屬於這個類型，就返回true
提示：一般用於在向下轉型之前，加這個判斷可以避免ClassCastException異常
（27）this：引用當前對象
this關鍵字：當前對象（2）在成員方法中，表示正在調用當前方法的對象
this的用法：（1）this.屬性 或 this.成員變量當局部變量與成員變量重名時，那么可以在成員變量的前面加this.進行區分
this.屬性，如果在本類中沒有找到，也可能表示引用從父類繼承到子類中可見的屬性
（2）this.成員方法()可以省略this.，表示訪問當前對象的其他成員方法
this.方法，如果在本類中沒有找到，也可能表示引用從父類繼承到子類中可見的方法
（3）this()或this(實參列表)當需要調用本類的其他構造器，可以在當前構造器的首行用this()或this(實參列表)進行調用
this()和this(實參列表)只會在本類中查找
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：原生的
只能修飾方法，表示這個方法的方法體不是用Java語言實現的，但是可以和普通的Java方法一樣去調用和重寫它。
（37）final：最終的
final：最終的，可以修飾類、方法、變量（1）類（包括外部類、內部類）：表示不能被繼承
（2）方法：不能被子類重寫，可以被繼承
（3）變量（包括成員變量和局部變量）：值不能修改，即為常量建議常量名大寫，每個單詞之間使用_分割，形式：XXX_YYY_ZZZ
如果變量是引用類型，變量地址值不可改變但指向的值可以改變，例如數組變量arr地址值不可變，但arr[0]元素值可以改變
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：易變的
表示該成員變量的值是易變的，每一次獲取它的值都要從主存中重新讀取，以保證在多線程中，不同線程讀取到的該值都是最新的。
因為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接口，那么在序列化過程中該成員變量不會參與序列化。
| 修飾符 | 外部類 | 成員變量 | 代碼塊 | 構造器 | 方法 | 局部變量 |
|---|---|---|---|---|---|---|
| public | √ | √ | × | √ | √ | × |
| protected | × | √ | × | √ | √ | × |
| private | × | √ | × | √ | √ | × |
| 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）修飾內部類：可以一起修飾成員內部類，不能一起修飾局部內部類
十、和異常處理相關的（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，也不需要程序員去關閉資源對象，無論是否發生異常，都會關閉資源對象
用於手動拋出異常
throw 異常對象;
throw可以用於拋出異常對象，如果它拋出的異常，沒有被catch的話，可以代替return語句結束當前方法，並將把異常對象帶回調用處。
用戶自定義異常只能使用throw語句手動拋出。
用於在方法簽名中，聲明該方法將拋出哪些類型的異常。
【修飾符】 返回值類型 方法名(【形參列表】) throws 異常類型列表{
}
表示這些異常在當前方法中沒有處理，交給調用者進行處理。
十一、assert（1個）
（48）assert：斷言
語法格式：
assert 布爾表達式;
或
assert 布爾表達式 : "錯誤信息";
注意：要開啟斷言功能，在eclipse中需要加JVM參數 -ea
（49）const：常數，不變的
在C語言等其他很多編程語言中用於聲明常量。在Java中沒有使用它。
（50）goto：跳轉
在C語言等其他很多編程語言中用於跳轉到指定位置。在Java中沒有使用它。
十三、特殊值（3個）
（51）true：真
（52）false：假
boolean值，通常用來作為條件。
boolean類型的變量，比較表達式（>,<,>=,<=,==,!=），邏輯表達式（&&,&,||,|,^,!），instanceof，這些都是boolean值。
（53）null：空，如果null調用屬性和方法會報空指針異常
這三個看似關鍵字，但是從技術角度來說，不能算是關鍵字，是特殊值。