🍺🍺變數和資料型別

變數，指的是程式運行時可變的量. 相當于開辟一塊記憶體空間來保存一些資料.
型別，則是對變數的種類進行了劃分, 不同的型別的變數具有不同的特性.

我們所討論的 “變數” 主要和我們的 “記憶體” 這樣的硬體設備密切相關

🥢🍚整型變數（敲重點）

基本語法格式
int 變數名 = 初始值;

代碼示例:

int num = 10; // 定義一個整型變數
System.out.println(num) ;

注意事項:
1. int 表示變數的型別是一個整型
2. 變數名是變數的標識. 后續都是通過這個名字來使用變數
3. Java 中 = 表示賦值(和數學不一樣), 意思是給變數設定一個初始值.
4. 初始化操作是可選的, 但是建議創建變數的時候都顯式初始化.
5. 最后不要忘記分號, 否則會編譯失敗.
6. // 表示注釋. 注釋作為代碼的解釋說明部分, 不參與編譯運行

在 Java 中, 一個 int 變數占 4 個位元組. 和作業系統沒有直接關系.

什么是位元組?
位元組是計算機中表示空間大小的基本單位.
計算機使用二進制表示資料. 我們認為 8 個二進制位(bit) 為一個位元組(Byte).
我們平時的計算機為 8GB 記憶體, 意思是 8G 個位元組.
其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
所以 8GB 相當于 80 多億個位元組

4 個位元組表示的資料范圍是 -2^31 -> 2^31-1 , 也就大概是 -21億 到 +21億
使用以下代碼查看 Java 中的整型資料范圍:（int屬于Integer包裝類）

System.out.println(Integer.MAX_VALUE);  // int 的最大值
System.out.println(Integer.MIN_VALUE);  // int 的最小值

如果運算的結果超出了 int 的最大范圍, 就會出現 溢位 的情況

21億這樣的數字對于當前的大資料時代來說, 是很容易超出的. 針對這種情況, 我們就需要使用 更大范圍的資料型別 來表示了.

Java 中提供了 long 型別.

🥢🍚長整型變數

基本語法格式:
long 變數名 = 初始值;

代碼示例:

注意事項:
1. 基本語法格式和創建 int 變數基本一致, 只是把型別修改成 long
2. 初始化設定的值為 10L , 表示一個長整型的數字. 10l 也可以.
3. 使用 10 初始化也可以, 10 的型別是 int, 10L 的型別是 long, 使用 10 L 或者 10 l 更好一些.
Java 中 long 型別占 8 個位元組. 表示的資料范圍 -2^63 -> 2^63-1

🥢🍚雙精度浮點型變數

基本語法格式:
double 變數名 = 初始值;

代碼示例:

double num = 1.0;
System.out.println(num);

示例代碼1：

int a = 1;
int b = 2;
System.out.println(a / b);
// 執行結果
0

在 Java 中, int 除以 int 的值仍然是 int(會直接舍棄小數部分).
如果想得到 0.5, 需要使用 double 型別計算.

double a = 1.0;
double b = 2.0;
System.out.println(a / b);
// 執行結果
0.5

示例代碼2：

double num = 1.1;
System.out.println(num * num);
    
// 執行結果
1.2100000000000002

Java 中的 double 雖然也是 8 個位元組, 但是浮點數的記憶體布局和整數差別很大, 不能單純的用 2 ^ n 的形式表示資料范圍.
Java 的 double 型別的記憶體布局遵守 IEEE 754 標準(和C語言一樣), 嘗試使用有限的記憶體空間表示可能無限的小數, 勢必會存在一定的精度誤差.

🥢🍚單精度浮點型變數

基本格式:
float 變數名 = 初始值;

代碼示例：

float num = 1.0f;    // 寫作 1.0F 也可以
System.out.println(num);

注意一個點：

float num = 1.0f;    
System.out.println(num);

這樣在C語言里頂多會報個警告，但是在java里，會之間報錯不通過
因為java是強型別語言，只要變數與變數型別不匹配，那么一定發會報錯

🥢🍚字符型別變數

基本格式:
char 變數名 = 初始值;

代碼示例：

char ch = 'A';
char hb = 97; //根據Unicode碼，輸出字符 a

注意事項:
1. Java 中使用 單引號 + 單個字母 的形式表示字符字面值.
2. 計算機中的字符本質上是一個整數. 在 C 語言中使用 ASCII 表示字符, 而 Java 中使用Unicode 表示字符. 因此一個字符占用兩個位元組, 表示的字符種類更多, 包括中文.

使用一個字符表示一個漢字:

char ch = '呵'; 
System.out.println(ch)

執行 javac 的時候可能出現以下錯誤:

Test.java:3: 錯誤: 未結束的字符文字
char ch = '鍛?'; 
^ 

此時我們在執行 javac 時加上 -encoding UTF-8 選項即可
javac -encoding UTF-8 Test.java

🥢🍚位元組型別變數

注意一個點:
Java定義了若干使用于運算式的型別提升規則：
所有的byte型. short型和char型將被提升到int型(例外: final修飾的short, char變數相加后不會被自動提升，)

基本格式:
byte 變數名 = 初始值;

代碼示例：
byte 1個位元組——>C里的char 位元組型別

byte value = 0; 
System.out.println(value);

注意事項：
1. 位元組型別表示的也是整數. 只占一個位元組, 表示范圍較小 ( -128 -> +127 )
不能這樣寫

byte value = 130; //130>128,超過了byte的范圍
System.out.println(value);

2. 位元組型別和字符型別互不相干

🥢🍚短整型變數

基本格式:
short 變數名 = 初始值;

代碼示例：

short value = 0; 
System.out.println(value);

注意事項:
1. short 占用 2 個位元組, 表示的資料范圍是 -32768 -> +32767
2. 這個表示范圍比較小, 一般不推薦使用

🥢🍚布爾型別變數

基本語法格式:
boolean 變數名 = 初始值;

代碼示例:

boolean value = true; 
System.out.println(value); 

注意事項:
1. boolean 型別的變數 只有兩種取值, true 表示真, false 表示假.
2. Java 的 boolean 型別和 int 不能相互轉換, 不存在 1 表示 true, 0 表示 false 這樣的用法.
3. boolean 型別有些 JVM 的實作是占 1 個位元組, 有些是占 1 個位元位, 這個 沒有明確規定.

典型錯誤實體

boolean value = true; 
System.out.println(value + 1); 

// 代碼編譯會出現如下錯誤
Test.java:4: 錯誤: 二元運算子 ‘+’ 的運算元型別錯誤
System.out.println(value + 1);
^
第一個型別: boolean
第二個型別: int
1 個錯誤

🥢🍚字串型別變數（敲重點）

把一些字符放到一起就構成了字串

基本語法格式:
String 變數名 = "初始值";

代碼示例:

String name = "zhangsan"; 
System.out.println(name); 

注意事項:
1. Java 使用 雙引號 + 若干字符 的方式表示字串字面值.
2. 和上面的型別不同, String 不是基本型別, 而是參考型別.
3. 字串中的一些特定的不太方便直接表示的字符需要進行轉義.
轉義字符示例:

// 創建一個字串 My name is "張三" 
String name = "My name is \"張三\"";

轉義字符有很多, 其中幾個比較常見的如下:

字串的 + 操作, 表示字串拼接:

String a = "hello"; 
String b = "world"; 
String c = a + b; 
System.out.println(c); 

還可以用字串和整數進行拼接:

String str = "result = "; 
int a = 10; 
int b = 20; 
String result = str + a + b; 
System.out.println(result); 
// 執行結果
result = 1020 

以上代碼說明, 當一個 + 運算式中存在字串的時候, 都是執行字串拼接行為.

因此我們可以很方便的使用 System.out.println 同時列印多個字串或數字

int a = 10; 
int b = 20; 
System.out.println("a = " + a + ",b = " + b)

🥢🍚變數的作用域

也就是該變數能生效的范圍, 一般是變數定義所在的代碼塊 (大括號)

class Test { 
public static void main(String[] args) { 
{ 
int x = 10; 
System.out.println(x); // 編譯通過; 
} 
System.out.println(x); // 編譯失敗, 找不到變數 x. 
} 
}

🥢🍚變數的命名規則

硬性指標:
1. 一個變數名只能包含數字, 字母, 下劃線
2. 數字不能開頭.
3. 變數名是大小寫 敏感 的 即 num 和 Num 是兩個不同的變數

注意: 雖然語法上也允許使用中文/美元符($)命名變數, 但是 強烈 不推薦這樣做.

軟性指標:
1. 變數命名要具有描述性, 見名知意.
2. 變數名不宜使用拼音(但是不絕對).
3. 變數名的詞性推薦使用名詞.
4. 變數命名推薦 小駝峰命名法, 當一個變數名由多個單詞構成的時候, 除了第一個單詞之外, 其他單詞首字母都大寫.

小駝峰命名示例:

int maxValue = 100; 
String studentName = "張三";

🥢🍚常量

上面討論的都是各種規則的變數, 每種型別的變數也對應著一種相同型別的常量.
常量指的是運行時型別不能發生改變.

常量主要有以下兩種體現形式:
1. 字面值常量

10 // int 字面值常量(十進制) 
010 // int 字面值常量(八進制) 由數字 0 開頭. 010 也就是十進制的 8 
0x10 // int 字面值常量(十六進制) 由數字 0x 開頭. 0x10 也就是十進制的 16 
10L // long 字面值常量. 也可以寫作 10l (小寫的L) 
1.0 // double 字面值常量. 也可以寫作 1.0d 或者 1.0D 
1.5e2 // double 字面值常量. 科學計數法表示. 相當于 1.5 * 10^2 
1.0f // float 字面值常量, 也可以寫作 1.0F 
true // boolen 字面值常量, 同樣的還有 false 
'a' // char 字面值常量, 單引號中只能有一個字符
"abc" // String 字面值常量, 雙引號中可以有多個字符. 

2. final 關鍵字修飾的常量

final int a = 10;
a = 20; // 編譯出錯. 提示 無法為最終變數a分配值
常量不能在程式運行程序中發生修改.

🥢🍚理解型別轉換

Java 作為一個強型別編程語言, 當不同型別之間的變數相互賦值的時候, 會有較嚴格的校驗.

先看以下幾個代碼場景:

int 和 long/double 相互賦值

int a = 10; 
long b = 20; 
a = b; // 編譯出錯, 提示可能會損失精度. 
b = a; // 編譯通過. 
int a = 10; 
double b = 1.0; 
a = b; // 編譯出錯, 提示可能會損失精度. 
b = a; // 編譯通過. 

long 表示的范圍更大, 可以將 int 賦值給 long, 但是不能將 long 賦值給 int.
double 表示的范圍更大, 可以將 int 賦值給 double, 但是不能將 double 賦值給 int.
結論: 不同數字型別的變數之間賦值, 表示范圍更小的型別能隱式轉換成范圍較大的型別, 反之則不行.

int 和 boolean 相互賦值

int a = 10; 
boolean b = true; 
b = a; // 編譯出錯, 提示不兼容的型別
a = b; // 編譯出錯, 提示不兼容的型別

結論: int 和 boolean 是毫不相干的兩種型別, 不能相互賦值.

int字面值常量 給 byte 賦值

byte a = 100; // 編譯通過
byte b = 256; // 編譯報錯, 提示 從int轉換到byte可能會有損失

注意: byte 表示的資料范圍是 -128 -> +127, 256 已經超過范圍, 而 100 還在范圍之內.
結論: 使用字面值常量賦值的時候, Java 會自動進行一些檢查校驗, 判定賦值是否合理.

使用強制型別轉換

int a = 0; 
double b = 10.5; 
a = (int)b; 
int a = 10; 
boolean b = false; 
b = (boolean)a; // 編譯出錯, 提示不兼容的型別. 

結論:
使用 (型別) 的方式可以將 double 型別強制轉成 int. 但是
1. 強制型別轉換可能會導致精度丟失. 如剛才的例子中, 賦值之后, 10.5 就變成 10 了, 小數點后面的部分被忽略.
2. 強制型別轉換不是一定能成功, 互不相干的型別之間無法強轉.

型別轉換小結
1. 不同數字型別的變數之間賦值, 表示范圍更小的型別能隱式轉換成范圍較大的型別.
2. 如果需要把范圍大的型別賦值給范圍小的, 需要強制型別轉換, 但是可能精度丟失.
3. 將一個字面值常量進行賦值的時候, Java 會自動針對數字范圍進行檢查.

🥢🍚理解數值提升

int 和 long 混合運算

int a = 10; 
long b = 20; 
int c = a + b; // 編譯出錯, 提示將 long 轉成 int 會丟失精度
long d = a + b; // 編譯通過.

結論: 當 int 和 long 混合運算的時候, int 會提升成 long, 得到的結果仍然是 long 型別, 需要使用 long 型別的變數來接收結果. 如果非要用 int 來接收結果, 就需要使用強制型別轉換.

byte 和 byte 的運算

byte a = 10; 
byte b = 20; 
byte c = a + b; 
System.out.println(c); 
// 編譯報錯
Test.java:5: 錯誤: 不兼容的型別: 從int轉換到byte可能會有損失
byte c = a + b; 
^ 

結論:
byte 和 byte 都是相同型別, 但是出現編譯報錯.
原因是, 雖然 a 和 b 都是 byte, 但是計算 a + b 會先將 a 和 b 都提升成 int, 再進行計算, 得到的結果也是 int, 這是賦給 c, 就會出現上述錯誤.
由于計算機的 CPU 通常是按照 4 個位元組為單位從記憶體中讀寫資料. 為了硬體上實作方便, 諸如 byte 和 short 這種低于4 個位元組的型別, 會先提升成 int, 再參與計算.

正確的寫法:

byte a = 10; 
byte b = 20; 
byte c = (byte)(a + b); 
System.out.println(c); 

型別提升小結:
1. 不同型別的資料混合運算, 范圍小的會提升成范圍大的.
2. 對于 short, byte 這種比 4 個位元組小的型別, 會先提升成 4 個位元組的 int , 再運算

🥢🍚int和String之間的相互轉換

String類屬于參考類，在Java中字串屬于物件，不同于int這種基礎資料型別
詳細String類后邊會專門出一篇博客，現不多做介紹

int 轉成 String

int num = 10; 
// 方法1 
String str1 = num + ""; 
// 方法2 
String str2 = String.valueOf(num); 

String 轉成 int

String str = "100"; 
int num = Integer.parseInt(str);

🍴🍴🍴小結

Java 型別匯總. 前面的內容重點介紹的是基本資料型別

隱式型別轉換和型別提升, 是本節的難點.
但是一般更推薦在代碼中避免不同型別混用的情況, 來規避型別轉換和型別提升的問題.

🍺🍺運算子

🥢🍚算術運算子

• 基本四則運算子 + - * / %

規則比較簡單, 值得注意的是除法:
a) int / int 結果還是 int, 小數需要使用 double 來計算.

int a = 1; 
int b = 2; 
System.out.println(a / b); 
// 結果為 0 

b) 0 不能作為除數

int a = 1; 
int b = 0; 
System.out.println(a / b) 
// 運行結果
Exception in thread "main" java.lang.ArithmeticException: / by zero 
 at Test.main(Test.java:5) 

c) % 表示取余, 不僅僅可以對 int 求模, 也能對 double 來求模

System.out.println(11.5 % 2.0); 
// 運行結果
1.5

• 增量賦值運算子 += -= *= /= %=
  這里需要注意一個點：符合運算子在使用時會自動強制型別轉換

short a = 10; 
a += 1; // 因為1是整型，混在一起是不能賦值給一個short型的，a=a+1會報錯
//a+=1等價于a = （int）（a + 1） 符合運算子可以自動強制轉換
System.out.println(a); 

• 自增/自減運算子 ++ –
  我們分析一下上面的代碼，如果這是一段c語言的代碼，那這個 j 最終的數值就是100了，但是在java里，java編譯器每次遇到自增自減的陳述句時，就會開辟一塊新的記憶體空間來保存，然后再將這個換成變數的值賦給左邊的變數，就像下面的代碼：

---

先來看一下j=j++；

temp = j;
j = j + 1;
j = temp;

我們再來看一下，如果換成 j = ++j;流程如下：

temp = j +1;
j = j + 1;
j = temp;

int a = 10; 
int b = ++a; 
System.out.println(b); 
int c = a++; 
System.out.println(c); 

結論:（Java里自增自減與C語言不同）
1. 如果不取自增運算的運算式的回傳值, 則前置自增和后置自增沒有區別.
2. 如果取運算式的回傳值, 則前置自增的回傳值是自增之后的值, 后置自增的回傳值是自增之前的值.
---------------------------------------------------------------------------------------------------------------------
差異：
Java代碼：

public class Test {
public static void main(String[] args) {
int a = 1;
a = a++;
System.out.println(a);//輸出結果為1
　　}
}

C語言代碼：

#include<stdio.h>
void main() {
int a = 1;
a = a++;
printf("%d",a);//輸出結果為2
}

===============================================================
在Java中我們可樣解釋，后加加運算a先自身加一，然后再將沒有運算的值賦給a，最終結果a=1，在c語言中是按照優先級來運算的，后加加優先級低，a先賦值給a自身，然后a再加加，最終結果a=2；

🥢🍚關系運算子

關系運算子主要有六個:

== != < > <= >=

int a = 10; 
int b = 20; 
System.out.println(a == b); 
System.out.println(a != b); 
System.out.println(a < b); 
System.out.println(a > b); 
System.out.println(a <= b); 
System.out.println(a >= b); 

注意: 關系運算子的運算式回傳值都是 boolean 型別(true/false).

🥢🍚邏輯運算子（敲重點）

邏輯運算子主要有三個:
&& || !
注意: 邏輯運算子的運算元(運算元往往是關系運算子的結果)和回傳值都是 boolean .

• 邏輯與 &&
  規則: 兩個運算元都為 true, 結果為 true, 否則結果為 false.

int a = 10; 
int b = 20; 
int c = 30; 
System.out.println(a < b && b < c); 

• 邏輯或 ||
  規則: 兩個運算元都為 false, 結果為 false, 否則結果為 true

int a = 10; 
int b = 20; 
int c = 30; 
System.out.println(a < b || b < c); 

• 邏輯非 !(只能作用到boolean型別的資料上)
  規則: 運算元為 true, 結果為 false; 運算元為 false, 結果為 true(這是個單目運算子, >只有一個運算元).

int a = 10; 
int b = 20; 
System.out.println(!a < b); 

• 短路求值
  && 和 || 遵守短路求值的規則.

System.out.println(10 > 20 && 10 / 0 == 0); // 列印 false 
System.out.println(10 < 20 || 10 / 0 == 0); // 列印 true 

我們都知道, 計算 10 / 0 會導致程式拋出例外. 但是上面的代碼卻能正常運行, 說明 10 / 0 并沒有真正被求值.

結論:
1. 對于 && , 如果左側運算式值為 false, 則運算式的整體的值一定是 false, 無需計算右側運算式
2. 對于 ||, 如果左側運算式值為 true, 則運算式的整體的值一定是 true, 無需計算右側運算式.

& 和 | (不推薦使用)
& 和 | 如果運算元為 boolean 的時候, 也表示邏輯運算. 但是和 && 以及 || 相比, 它們不支持短路求值.

System.out.println(10 > 20 & 10 / 0 == 0); // 程式拋出例外
System.out.println(10 < 20 | 10 / 0 == 0); // 程式拋出例外

🥢🍚位運算子

Java 中對資料的操作的最小單位不是位元組, 而是二進制位.

位運算子主要有四個:
& | ~ ^
位操作表示 按二進制位運算. 計算機中都是使用二進制來表示資料的(01構成的序列), 按位運算就是在按照二進制位的每一位依次進行計算.

按位與 &: 如果兩個二進制位都是 1, 則結果為 1, 否則結果為 0.

int a = 10; 
int b = 20; 
System.out.println(a & b); 

進行按位運算, 需要先把 10 和 20 轉成二進制, 分別為 1010 和 10100

按位或 |: 如果兩個二進制位都是 0, 則結果為 0, 否則結果為 1.

int a = 10; 
int b = 20; 
System.out.println(a | b);

運算方式和按位于類似.

注意: 當 & 和 | 的運算元為整數(int, short, long, byte) 的時候, 表示按位運算, 當運算元為 boolean 的時候, 表示邏輯運算.

🥢🍚移位運算子（了解）

移位運算子有三個:
<< >> >>>
都是按照二進制位來運算.

左移 <<: 最左側位不要了, 最右側補 0.

int a = 0x10; 
System.out.printf("%x\n", a << 1); 
// 運行結果(注意, 是按十六進制列印的) 
20 

右移 >>: 最右側位不要了, 最左側補符號位(正數補0, 負數補1)

int a = 0x10; 
System.out.printf("%x\n", a >> 1); 
// 運行結果(注意, 是按十六進制列印的) 
8 

int b = 0xffff0000; 
System.out.printf("%x\n", b >> 1); 
// 運行結果(注意, 是按十六進制列印的) 
ffff8000

無符號右移 >>>: 最右側位不要了, 最左側補 0.

int a = 0xffffffff; 
System.out.printf("%x\n", a >>> 1); 
// 運行結果(注意, 是按十六進制列印的) 
7fffffff

注意:
1. 左移 1 位, 相當于原數字 * 2. 左移 N 位, 相當于原數字 * 2 的N次方.
2. 右移 1 位, 相當于原數字 / 2. 右移 N 位, 相當于原數字 / 2 的N次方.
3. 由于計算機計算移位效率高于計算乘除, 當某個代碼正好乘除 2 的N次方的時候可以用移位運算代替.
4. 移動負數位或者移位位數過大都沒有意義.

🥢🍚條件運算子

條件運算子只有一個:
運算式1 ? 運算式2 : 運算式3
當 運算式1 的值為 true 時, 整個運算式的值為 運算式2 的值;
當 運算式1 的值為 false 時, 整個運算式的值為 運算式3 的值.
也是 Java 中唯一的一個 三目運算子, 是條件判斷陳述句的簡化寫法.

// 求兩個整數的最大值
int a = 10; 
int b = 20; 
int max = a > b ? a : b;

🥢🍚運算子的優先級

先看一段代碼

System.out.println(1 + 2 * 3); 

結果為 7, 說明先計算了 2*3 , 再計算 1+
另外一個例子

System.out.println(10 < 20 && 20 < 30); 

此時明顯是先計算的 10 < 20 和 20 < 30, 再計算 &&. 否則 20 && 20 這樣的操作是語法上有誤的(&& 的運算元只能是boolean).

運算子之間是有優先級的. 具體的規則我們不必記憶. 在可能存在歧義的代碼中加上括號即可.

🍴🍴🍴小結

1. % 操作在 Java 中也能針對 double 來計算.
2. 需要區分清楚 前置自增 和 后置自增 之間的區別.
3. 由于 Java 是強型別語言, 因此對于型別檢查較嚴格, 因此像 && 之類的運算運算元必須是 boolean.
4. 要區分清楚 & 和 | 什么時候是表示按位運算, 什么時候表示邏輯運算.
整體來看, Java 的運算子的基本規則和 C 語言基本一致.

🍺🍺注釋

注釋是為了讓代碼更容易被讀懂而附加的描述資訊. 不參與編譯運行, 但是卻非常重要.時刻牢記! 代碼寫出來是為了給人看的, 更是為了給三個月后的你自己看的.

🥢🍚基本規則

Java中的注釋主要分為以下三種

單行注釋：// 注釋內容（用的最多）
多行注釋：/* 注釋內容*/（不推薦）
檔案注釋： /** 檔案注釋 */（常見于方法和類之上描述方法和類的作用)，可用來自動生成檔案

🥢🍚注釋規范

1. 內容準確: 注釋內容要和代碼一致, 匹配, 并在代碼修改時及時更新.
2. 篇幅合理: 注釋既不應該太精簡, 也不應該長篇大論.
3. 使用中文: 一般中國公司都要求使用中文寫注釋, 外企另當別論.
4. 積極向上: 注釋中不要包含負能量(例如 領導 SB 等)

🍺🍺關鍵字

關鍵字是 Java 中的一些具有特定含義的單詞.

Java關鍵字是對Java編譯器有特殊含義的字串，是編譯器和程式員的一個約定，程式員利用關鍵字來告訴編譯器其宣告的變數型別、類、方法特性等資訊，Java語言共定義了如下所示的關鍵字，

關鍵字
abstract
表明類或者成員方法具有抽象屬性
assert
斷言，用來進行程式除錯
boolean
基本資料型別之一，宣告布爾型別的關鍵字
break
提前跳出一個塊
byte
基本資料型別之一，位元組型別
case
用在switch陳述句之中，表示其中的一個分支
catch
用在例外處理中，用來捕捉例外
char
基本資料型別之一，字符型別
class
宣告一個類
const
保留關鍵字，沒有具體含義
continue
回到一個塊的開始處
default
默認，例如，用在switch陳述句中，表明一個默認的分支，Java8 中也作用于宣告介面函式的默認實作
do
用在do-while回圈結構中
double
基本資料型別之一，雙精度浮點數型別
else
用在條件陳述句中，表明當條件不成立時的分支
enum
列舉
extends
表明一個型別是另一個型別的子型別，對于類，可以是另一個類或者抽象類；對于介面，可以是另一個介面
final
用來說明最終屬性，表明一個類不能派生出子類，或者成員方法不能被覆寫，或者成員域的值不能被改變，用來定義常量
finally
用于處理例外情況，用來宣告一個基本肯定會被執行到的陳述句塊
float
基本資料型別之一，單精度浮點數型別
for
一種回圈結構的引導詞
goto
保留關鍵字，沒有具體含義
if
條件陳述句的引導詞
implements
表明一個類實作了給定的介面
import
表明要訪問指定的類或包
instanceof
用來測驗一個物件是否是指定型別的實體物件
int
基本資料型別之一，整數型別
interface
介面
long
基本資料型別之一，長整數型別
native
用來宣告一個方法是由與計算機相關的語言（如C/C++/FORTRAN語言）實作的
new
用來創建新實體物件
package
包
private
一種訪問控制方式：私用模式
protected
一種訪問控制方式：保護模式
public
一種訪問控制方式：共用模式
return
從成員方法中回傳資料
short
基本資料型別之一,短整數型別
static
表明具有靜態屬性
strictfp
用來宣告FP_strict（單精度或雙精度浮點數）運算式遵循IEEE 754算術規范
super
表明當前物件的父型別的參考或者父型別的構造方法
switch
分支陳述句結構的引導詞
synchronized
表明一段代碼需要同步執行
this
指向當前實體物件的參考
throw
拋出一個例外
throws
宣告在當前定義的成員方法中所有需要拋出的例外
transient
宣告不用序列化的成員域
try
嘗試一個可能拋出例外的程式塊
void
宣告當前成員方法沒有回傳值
volatile
表明兩個或者多個變數必須同步地發生變化
while
用在回圈結構中
另外, 定義的變數名不能和關鍵字沖突.

?原創不易，如有錯誤，歡迎評論區留言指出，感激不盡?
?如果覺得內容不錯，給個三連不過分吧~ ?
?看到會回訪~ ?