Java語言基礎（一）---關鍵字、識別符號、註釋、常量、變數、運算子

阿新 • • 發佈：2018-12-10

Java語言基礎組成：關鍵字、識別符號、註釋、常量和變數、運算子、語句、函式、陣列

一. 關鍵字

【注】關鍵字的所有的字母都是小寫

1. 用於定義資料型別的關鍵字

基本資料型別	數值型	整數：byte（位元組） short（短整型） int （整型） long（長整型）
		浮點數： float（單精度浮點數） double（雙精度浮點數）
	字元型	char（字元型）
	布林型	boolean（布林型）
引用資料型別	chass（類） interface（介面）
void（表示函式的返回值是無返回值型別）

2. 用於定義資料型別值的關鍵字
true（真） false（假） null（空）

3. 用於定義流程控制的關鍵字

迴圈結構	if（如果） else（否則）
選擇結構	switch case default（預設）
迴圈結構	while do for
其他流程控制語句	break（跳出） continue（繼續） return（返回）

4. 用於定義訪問許可權修飾符的關鍵字
private（私有） protected（保護） public（公有）

5. 用於定義類，函式，變數修飾符的關鍵字
abstract（抽象） final（最終） static（靜態） synchronized（同步） Enum（列舉）

6. 用於定義類與類之間的關鍵字
extends（繼承類） implements（實現介面）

7. 用於定義建立例項及引用例項，判斷例項的關鍵字
new（例項化類） this（本類物件） super（父類物件） instanceof（判斷物件型別）

8. 用於異常處理的關鍵字
try（檢查異常） catch（抓住異常） finally（發生異常後最終執行）
throw（程式中例項化異常丟擲） throws（標識方法丟擲異常）

9. 用於包的關鍵字
package（建立包名） import（引入包名）

10. 其他修飾符關鍵字

native（本地）

native關鍵字說明其修飾的方法是一個原生態方法，方法對應的實現不是在當前檔案，而是在用其他語言（如C和C++）實現的檔案中。

strictfp（strict float point (精確浮點)）

使用strictfp關鍵字宣告一個方法時，該方法中所有的float和double表示式都嚴格遵守FP-strict的限制,符合IEEE-754規範。當對一個類或介面使用 strictfp 關鍵字時，該類中的所有程式碼，包括巢狀型別中的初始設定值和程式碼，都將嚴格地進行計算。

transient（變數修飾符，用它宣告一個例項變數，在物件序列化時不會被序列化）

當物件被序列化時（寫入位元組序列到目標檔案）時，transient阻止例項中那些用此關鍵字宣告的變數持久化；當物件被反序列化時（從原始檔讀取位元組序列進行重構），這樣的例項變數值不會被持久化和恢復。例如，當反序列化物件——資料流（例如，檔案）可能不存在時，原因是你的物件中存在型別為java.io.InputStream的變數，序列化時這些變數引用的輸入流無法被開啟。

volatile（型別修飾符，用來修飾被不同執行緒訪問和修改的變數）

Java 語言提供了一種稍弱的同步機制,即 volatile 變數.用來確保將變數的更新操作通知到其他執行緒,保證了新值能立即同步到主記憶體,以及每次使用前立即從主記憶體重新整理. 當把變數宣告為volatile型別後,編譯器與執行時都會注意到這個變數是共享的.

assert （斷言，可以看作是異常處理的一種高階形式，用於捕捉我們在程式碼中做出的假設）

在Java中，assert關鍵字是從JAVA SE 1.4 引入的，為了避免和老版本的Java程式碼中使用了assert關鍵字導致錯誤，Java在執行的時候預設是不啟動斷言檢查的（這個時候，所有的斷言語句都將忽略！），如果要開啟斷言檢查，則需要用開關-enableassertions或-ea來開啟。

二. 識別符號

識別符號是在程式中自定義的一些名稱，由大小寫字母[a-zA-Z]，數字[0-9]，下劃線[ _ ]，特殊字元[$]組成。

1. 識別符號的命名規則：

（1）數字不可以開頭
（2）不可以使用關鍵字
（3） Java中嚴格區分大小寫

【注】“main”不是關鍵字，但被JVM（Java虛擬機器）識別

2. 識別符號的名稱規範：

（1）包名：多個單片語成時，所有字母小寫
e.g. xxxyyyzzz
（2）類名和介面名：多個單片語成時，所有單詞首字母大寫
e.g. XxxYyyZzz
（3）變數名和函式名：多個單片語成時，第一個單詞首字母小寫，第二個單詞開始每個單詞首字母大寫
e.g. xxxYyyZzz
（4）常量名：多個單片語成，所有字母大寫，每個單詞用下劃線連線
e.g. XXX_YYY_ZZZ

三. 註釋

Java的註釋有三種：單行註釋，多行註釋，文件註釋（是程式的說明書，Java特有的，使用javadoc執行程式可以提取出來形成網頁，給開發人員看的）。

//（單行註釋）

/*
（多行註釋）
*/

/**
（文件註釋）
@author 作者
@version 版本號
*/

1. 註釋的作用：

（1）註解說明程式，但是注意不要每一行都加註釋，不然會導致中英文結合地非常密，閱讀性差
（2）除錯程式（很重要的應用）

2. 註釋的問題：

（1）單行註釋中能夠使用單行註釋
（2）多行註釋中能夠使用單行註釋
（3）多行註釋中不能使用多行註釋，文件註釋
（4）文件註釋中不能使用文件註釋，多行註釋

3. 註釋的分別用法：

（1）類上面加的是文件註釋
（2）函式上面加的是文件註釋
（3）如果修飾符有改變的話，加多行註釋
（4）程式碼中的某幾句話，加單行註釋

四. 常量

常量不能被改變數值

1. 常量包括：

（1）整數常量
（2）小數常量
（3）布林型常量：true，false
（4）字元常量：’4’，單個字母
（5）字串常量：”abc”
（6）null常量，值為null

2. 整數常量：

（1）十進位制[0-9]，滿10進1
（2）八進位制[0-7]，用0開頭
（3）十六進位制[0-9A-F]，用0x開頭
（4）二進位制[0-1]，8位1,0表示一個位元組，位元組是一個數據單位。
【注】ASCII碼使用指定的7位或8位二進位制數組合來表示128或256種可能的字元。
e.g. 01000001表示A
e.g. 01000010表示B

2.1 十進位制->二進位制：

原理：對十進位制數進行除2運算

【例項】：6的二進位制

6的二進位制

System.out.println(Integer.toBinaryString(6)); //列印結果為110

2.2 二進位制->十進位制：

原理：對二進位制數乘以 $2^n$ 運算（n是從0開始）

【例項 1】：110 => $0*2^0 +1*2^1+1*2^2 = 6$

【例項 2】：00110101的十進位制（便捷式）

00110101的十進位制（便捷式）

（【注】8個1 = 255； 7個1 = 127）

【例項 3】：5 + 4 = 9 記憶體中的演算法：101 + 100 = 1001 =>9

2.3 二進位制->十六進位制：

原理：四個二進位制位就是一個十六進位制位（1111 => 15 = $2^4-1$ ）

【例項】：十進位制90的十六進位制

十進位制90的十六進位制

2.4 二進位制->八進位制：

原理：三個二進位制位就是一個八進位制位（111 => 7 = $2^3-1$ ）

【例項】：十進位制90的八進位制

十進位制90的八進位制

【注】其他進位制轉換：先把十進位制轉換為二進位制，再對應地進行轉換

2.5 負數的二進位制變現形式：

6 =>110
-6：其實就是6的二進位制取反+1（取反：將二進位制的1變成0，0變成1）
【注】整數在記憶體中為4個位元組，1個位元組為8位

【例項 1】：十進位制6的轉換為-6的過程

十進位制6的轉換為-6的過程

結論：負數的最高位都是1，取反得來。

【例項 2】：（拓展）求111…111001=？【解題思路】：先減1，再取反，再加負號

求111...111001=？

五. 變數

變數就是將不確定的資料進行儲存，也就是需要在記憶體中開闢一個空間。（Java是強型別語言）

【注】：Java在方法中定義的變數不會自動初始化，必須要我們給它初始化後才能使用它。在類中定義的變數會自動初始化。

1. 變數的初始化：

（1）Java在方法中定義的變數不會自動初始化，必須要我們給它初始化後才能使用它。
（2）在類中定義的變數會自動初始化。

2. 變數的作用域：

Java中變數的作用域——大括號劃分

{
    int x = 9;
}
System.out.println(x); //不可以在大括號外呼叫X

3. 變數的巢狀定義：

（1）Java同一函式中變數不允許巢狀定義（和C語言中不同）

public static void main(String[] args)
{
    int x = 3;
    {
        int x = 9; //不允許巢狀定義
        System.out.println(x);
    }
    System.out.println(x);
}

（2）Java同一類中允許方法中的變數與成員變數同名

class Demo
{
    private int x;
    public int getX()
    {
        int x = ++this.x;
        return x; //此處呼叫的是方法中定義的x,而非類的成員變數
    }
}

六. 運算子

處理資料的原理就是運算。運算子包括：算術運算子，賦值運算子，比較運算子，邏輯運算子，位運算子，三元運算子。

1. 算術運算子：

+（正號）	-（負號）
+（加）	-（減）	*（乘）	/（除）【e.g.】5 / 5 = 1
%（取模）規律：左邊小於右邊 = 左邊【e.g.】 2 %5 = 2; 左邊等於右邊 = 0 【e.g. 】5 %5 = 0; 右邊等於1 = 0 【e.g. 】5 %1 = 0;
+（字串相加）字串資料和任何資料使用【+】都是相連線，最終都會變成字串【e.g.】(“He” + “llo”) =>(“Hello”)
++（自增）	自增前（先自增，後賦值）： a = 2; b = ++a; => a = 3 ; b = 3;
	自增後（先賦值，後自增）： a = 2; b = a++; => a = 3 ; b = 2;
	【總結】：a++; => a = a + 1; a++和++a運算過後，a的值都增加1
- -（自減）	自減前（先自減，後賦值）： a = 2; b = - -a; => a = 1 ; b = 1;
	自減後（先賦值，後自減）： a = 2; b = a- -; => a = 1 ; b = 2;

【例項】：”+” 字串連線符的用法

System.out.println("5+5=" + 5 + 5); //5+5=55
System.out.println("5+5=" + (5+5)); //5+5=10
System.out.println("a=" + a + ", b=" + b); //a=4, b=5

2. 賦值運算子

=（賦值）	+=（和賦值）	-=（差賦值）	*=（積賦值）	/=（商賦值）	%=（餘數賦值）
【注】：以上的符號如”-=” 都是僅為一個運算子符號

【例項1】x += 4; => x = x + 4;
左右兩邊的和賦值給左邊

【例項2】兩個賦值方法對比

short s = 4; s = s + 4;	short s = 4; s += 4;
先做加法，再做賦值，有自動型別提升的過程	這個只做了一次運算，只是運用了賦值運算子，把左右兩邊的和賦值給左邊
【編譯失敗】，因為s會被提升為int型別，運算後的結果還是int型別，無法賦值給short型別	【編譯成功】，因為”+=”賦值運算子在給s賦值時，自動完成了強轉操作
總結：s = (short) (s + 4)這樣才能將和賦值給s	總結：(1)s = 4; (2)s += 4; 這兩個表示式都只用了賦值運算子，將int型別賦值給short型，會進行自動型別轉換

3. 比較運算子：

比較運算子結果都是boolean型，true 或者 false。

==（相等）	！=（不相等）	$<$ （小於）	$>$ （大於）	$<=$ （小於等於）	$>=$ （大於等於）
instanceof（檢查是否是類的物件）

【例項】：

System.out.println("Hello" instanceof String); //true
System.out.println(3 > 4); //false

4. 邏輯運算子：

邏輯運算子代表關係，用於連線boolean型別的表示式。

&	And （與）	true & true = true true & false = false false & true = false false & false = false	【結論】：兩邊只要有一個為false，結果就是false，兩邊只要都為true，結果為true。	【例項】： int x = 4; x > 3 & x $<$ 4 = false; true & true = true;
\|	or （或）	true \| true = true true \| false = true false \| true = true false \| false = false	【結論】：兩邊只要有一個true，結果為true，兩邊只要都為false，結果為false。
^	xor （異或）	true ^ true = false true ^ false = true false ^ true = true false ^ false = false	【結論】：兩邊相同，結果為false，兩邊不同，結果為true。
！	Not （非）	！true = false
&&	And （短路）	【 & 與 && 的區別】： &：無論左邊是true，還是false，右邊都運算。 &&：當左邊為false時，右邊不運算，因為結果肯定為false，左邊為true，右邊參與運算。
\|\|	or （短路）	【 \| 與 \|\| 的區別】： \|：無論左邊是true，還是false，右邊都運算。 \|\|：當左邊為true時，右邊不運算，因為結果肯定為true，左邊為false，右邊參與運算。

5. 位運算子：

位運算子是二進位制運算的運算子，“位”是二進位制的位，是最快的運算，但侷限是基為2。

$<<$	左移	3 $<<$ 2 => $3 * 2 ^2 = 12$
$>>$	帶符號右移	3 $>>$ 1 => $3$ / $2 ^1 = 1$	高位空出來要補什麼？按原有資料的高位置是0補0，是1補1。
$>>>$	無符號右移	3 $>>>$ 1 => $3$ / $2 ^1 = 1$	右移空出來都拿0補
&	與運算	6 & 3 = 2
\|	或運算	6 \| 3 = 7
^	異或運算	6 ^ 3 = 5
~	反碼	~6 = -7

【例項】：左移，右移，無符號右移之間的區別

【 1. $<<$ 與 $>>$ 的區別】：
$<<$ （左移）	其實就是乘以2的移動位數為次冪
$>>$ （右移）	其實就是除以2的移動位數為次冪
【 2. $>>$ 時，正數和負數的區別】：
$>>$ （正數右移時）	高位補0
$>>$ （負數右移時）	高位補1
【 3. $>>$ 與 $>>>$ 的區別】：
$>>$ （帶符號右移）	高位補0或1：具體看原有值高位，是0補0，是1補1
$>>>$ （無符號右移）	高位都補0

5.1 <<（左移）：

【例項】： 3 $<<$ 2 => $3 * 2 ^2 = 12$

左移例項

【總結】：m $<<$ n => $m * 2 ^n$ （向左邊移動，右邊用0補。）

5.2 >>（右移）：

【例項 1】：正數右移：3 $>>$ 1 => $3$ / $2 ^1 = 1$

右移例項正數

【總結】：m $>>$ n => $m$ / $2 ^n$

【例項 2】：負數右移： $-$ 3 $>>$ 1 => $-3$ / $2 ^1 = -2$

（1）將3轉換為二進位制的-3（取反加1）
（2）將二進位制的-3右移1位，高位用1補（負數高位為1）
（3）將二進位制的-3轉換為十進位制（減1取反）

右移例項負數

【總結】：負數右移還是負數。

5.3 >>>（無符號右移）：

【例項 1】：正數無符號右移：3 $>>>$ 1 => $3$ / $2 ^1 = 1$

無符號右移例項正數

【例項 2】：負數無符號右移：-3 $>>>$ 1 => $-3$ / $2 ^1 = 2147483646$

無符號右移例項正數

【總結】：如果是負數右移的話，高位也補0，此時的數就轉變為了正數

5.4 &（與運算）：

【例項】： 6 & 3 = 2

&（與運算）

5.5 | （或運算）：

【例項】： 6 | 5 = 7

| （或運算）

5.6 ^（異或運算）：

【例項 1】： 6 ^ 5 = 3

^（異或運算）

【例項 2】：異或運算還可以用於加密解密： 7 ^ 4 ^ 4 = 7;（“4”相當於金鑰）

加密解密

【總結】：一個數異或同一個數兩次，結果是本身。

5.7 ~（反碼）：

【例項】： ~6 = -7 步驟：（1）取反，（2）減1，（3）取反，（4）加負號

~（反碼）

5.8 位運算練習：

【例項 1】：最有效的方式算出2乘以8等於幾？

解： 2 * 8 = $2 * 2 ^3$ => 2的二進位制位向左移了3位；
2的二進位制為000..0000-0010
左移了3位：000..0001-0000 => 16

【例項 2】：對兩個整數變數的值進行交換（不需要第三方變數）

// （1）使用第三方變數
    int n = 3, m = 8;
    int temp;
    temp = n;
    n = m;
    m = temp;

// （2）不需要使用第三方變數，利用兩數的和
    n = n + m;
    m = n - m;
    n = n - m;

// （3）不需要使用第三方變數，利用異或同一個數兩次還是本身
    n = n ^ m;
    m = n ^ m; //m = (n ^ m) ^ m;
    n = n ^ m; //n = (n ^ m) ^ n;

【例項 3】： 60（十進位制）轉換為十六進位制，用程式碼

60（十進位制）轉換為十六進位制

public static void main(String[] args) 
    {
        int num = 60;

        //取出最低4位，方法：通過&15
        int n1 = num & 15;

        //輸出最低4位的十六進位制值
        System.out.println(n1 > 9 ? (char)(n1 - 10 + 'A') : n1); 
        //char是兩個位元組，int是四個位元組，(n1 - 10 + 'A')會自動型別提升為int型，所以輸出結果為67

        //獲取下一組4位，右移4位
        int temp = num >>> 4;
        int n2 = temp & 15;
        System.out.println(n2 > 9 ? (char)(n2 - 10 + 'A') : n2);
    }

【例項 4】：（擴充套件） -60（十進位制）轉換為十六進位制

-60（十進位制）轉換為十六進位制

6. 三元運算子：

（條件表示式）？表示式 1 ：表示式 2； =>一定有結果

（1）如果條件為true，運算後的結果為表示式 1；
（2）如果條件為false，運算後的結果為表示式 2；