Java程式設計複習提綱（上：入門語法）

孤飛發表於2023-05-18

Java程式設計

基本語法與編譯執行

java沒有指標沒有全域性變數
Java原始碼檔案的字尾名是".java"。編譯後會生成一個或多個位元組碼檔案，字尾名為".class"。
Java的編譯器是javac，直譯器是java。使用javac編譯原始碼，然後用java執行編譯後的位元組碼。
Java中的每一行程式碼都需要以分號（;）結束。
Java語言對大小寫敏感，類名的首字母應該大寫，而方法名應該以小寫字母開頭。
Java的主方法（程式的入口點）的宣告應為：public static void main(String args[])。

資料型別和關鍵字

package語句可以沒有，有的話必須放在檔案開始的地方
public類每個檔案中最多有一個
Java的註釋：單行註釋（//）、多行註釋（/.../）和文件註釋（/**...*/），其中文件註釋必須出現在公有類定義或公有方法頭前面，為將來的維護人員提供API
Java的true、false、null都是小寫的
Java原始碼使用的是Unicode碼，而不是ASCII碼
類名多為名詞，含有大小寫，首字母要求大寫；介面名的命名約定與類名相同
Java不允許用數字0,1表示邏輯值
Java資料型別：

另外字元資料還有string字串。String類提供了許多用於操作字串的方法，如連線字串、比較字串、查詢子字串等。

因此，char和String在Java中都有其用處。如果你只需要處理單個字元，可以使用char型別；如果你需要處理一個字元序列，或者需要使用到字串操作的方法，應該使用String類。

以下是一些例子：

javaCopy codechar c = 'a'; // char型別

String s = "Hello, world!"; // String型別

// 使用String類的方法
int length = s.length(); // 獲取字串的長度
String upper = s.toUpperCase(); // 將字串轉換為大寫

0開頭表示8進位制數、0x表示16進位制數、077L表示長整型的8進位制數
Java型別轉換主要包括自動型別轉換（也叫隱式型別轉換）和強制型別轉換（也叫顯式型別轉換）：自動型別轉換是指從較小的資料型別自動轉換到較大的資料型別（如int轉為double）；而強制型別轉換則需要在表示式前顯式地加上要轉換的型別（如double轉為int，可能會導致精度丟失）。

double myDouble = 9.78;
int myInt = (int) myDouble;  // 強制型別轉換

在Java中，可以使用四種訪問修飾符來修飾類和類的成員（如欄位和方法）。這些訪問修飾符決定了其他類可以訪問的範圍。以下是這四種訪問修飾符（包括無修飾符，即預設）的訪問許可權：

訪問許可權	同一類	同一包中的子類	同一包中的非子類	不同包中的子類	不同包中的非子類
無修飾符（預設）	是	是	是	否	否
`private`	是	否	否	否	否
`protected`	是	是	是	是	否
`public`	是	是	是	是	是

(1). 無修飾符（預設）：只能被同一個包內的類訪問。
(2). private：只能在同一類中被訪問。
(3). protected：可以在同一包中的任何類以及其他包中的子類中被訪問。
(4). public：可以在任何地方被訪問。

類中定義的公有靜態變數相當於全域性變數。
在Java中，"全域性變數"這個術語通常不被使用，因為Java沒有像C或C++那樣的真正意義上的全域性變數。然而，類中定義的公有靜態變數（public static variables）在某種意義上可以視為"全域性變數"，因為它們可以在類的任何例項或者甚至在類的外部被訪問和修改。

當我們在一個類中宣告一個變數為public static時，這就意味著這個變數屬於這個類，而不是類的任何一個例項。這個變數在記憶體中只有一個複製，所有的例項都共享這一個變數。
```
javaCopy codepublic class MyClass {
    public static int count = 0;  // 公有靜態變數
}
```
在這個例子中，count就是一個公有靜態變數。我們可以在任何地方透過MyClass.count來訪問和修改這個變數，無論我們建立了多少個MyClass的例項。這就是為什麼公有靜態變數在某種意義上可以視為"全域性變數"。

但是要注意的是，這並不意味著使用公有靜態變數就是一種好的做法。在許多情況下，這樣做可能會導致程式碼更難理解和維護，因為任何程式碼都可以修改公有靜態變數的值，這可能會導致意想不到的副作用和錯誤。因此，除非有特別的理由，否則通常最好避免使用公有靜態變數。

void是一個關鍵字，用於指定一個方法不返回任何值。

public void printHello() {
    System.out.println("Hello, world!");
}

15.在處理物件賦值這個問題上，Java和Python實際上有很多相似之處，因為它們都使用引用語義來處理物件。也就是說，當你在Java或Python中將一個物件賦值給另一個變數時，你實際上是在複製物件的引用，而不是整個物件。這意味著賦值後的兩個變數指向的是同一個物件，對其中一個變數的任何修改都會影響到另一個變數。

然而，Java和Python在如何處理基本資料型別（如整數和浮點數）上有所不同：

在Java中，基本資料型別（如int，double等）不是物件，它們是直接儲存的值。當你將一個基本型別的變數賦值給另一個變數時，Java會複製這個值，而不是引用。因此，修改一個變數不會影響到另一個變數。
而在Python中，所有的東西都是物件，包括整數和浮點數。這意味著當你在Python中複製一個整數或浮點數時，你實際上是在複製一個引用。但是，因為Python中的數值型別是不可變的（即你不能修改它們的值），所以在實際使用中，這種差異通常不會引起問題。

在處理陣列和其他容器型別時，這種差異就變得更加明顯了。例如，如果你在Java中複製一個陣列，你會得到一個新的陣列，它的元素是原陣列的引用。如果你修改了新陣列的元素，原陣列也會被改變。但是，如果你在Python中複製一個列表，你會得到一個新的列表，它的元素是原列表的引用。如果你修改了新列表的元素，原列表不會被改變。這是因為在Python中，列表的賦值實際上是建立了一個新的列表物件，而這個新列表的元素是原列表的元素的引用。

在Java中：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = a;
        a = 3;
        System.out.println("a: " + a); // 輸出 "a: 3"
        System.out.println("b: " + b); // 輸出 "b: 5"
    }
}

在這個Java程式碼中，我們首先宣告瞭變數a並賦值為5，然後宣告瞭變數b並將a的值賦給它。然後我們改變a的值為3。由於Java中的int是基本資料型別，所以b的值是a在賦值時的值，改變a的值並不會影響到b。所以最後，a的值為3，b的值仍為5。

在Python中：

a = 5
b = a
a = 3
print('a:', a)  # 輸出 "a: 3"
print('b:', b)  # 輸出 "b: 5"

在這個Python程式碼中，我們首先建立了一個數值物件5並讓a引用它，然後讓b引用a引用的物件。然後我們建立了一個新的數值物件3並讓a引用它。Python的數值物件是不可變的，所以我們實際上是建立了一個新的數值物件，而不是修改了原來的數值物件。因此，改變a的引用並不會影響到b。所以最後，a的值為3，b的值仍為5。

總的來說，不論是在Java還是Python中，修改原始變數並不會影響到被賦值的變數。這是因為在這兩種語言中，數值賦值都是透過建立新的數值物件實現的，而不是直接修改原來的數值物件。

對於字串結果也是一樣的。

在Java中，成員變數（也稱為欄位、屬性或例項變數）和靜態變數會有預設初始化，而區域性變數則必須顯式初始化才能使用。

成員變數和靜態變數：如果你在類中宣告一個欄位但沒有給它賦值，Java會為其提供一個預設值。具體預設值取決於欄位的資料型別。例如，數字型別的預設值是0，布林型別的預設值是false，引用型別（類、介面等）的預設值是null。
區域性變數：這是在方法、建構函式或者程式碼塊中定義的變數。區域性變數在使用前必須顯式初始化，否則編譯器將報錯。這是因為區域性變數儲存在棧上，而不是像成員變數和靜態變數那樣儲存在堆上，Java不會為棧上的變數提供預設值。

例如，以下的Java程式碼將無法編譯：

javaCopy codepublic class Main {
    public static void main(String[] args) {
        int a; // 這是一個區域性變數
        System.out.println(a); // 編譯錯誤：變數a可能尚未初始化
    }
}

你需要先給變數a賦值，才能使用它：

javaCopy codepublic class Main {
    public static void main(String[] args) {
        int a = 5; // 這是一個區域性變數
        System.out.println(a); // 輸出：5
    }
}

常用語法

邏輯運算子

Java中的邏輯運算子主要有以下幾種：

（1）. &&：邏輯與（AND）運算子。當且僅當兩個運算元都為true時，結果才為true。例如：(5 > 3) && (2 > 3)的結果是false。
（2）. ||：邏輯或（OR）運算子。只要兩個運算元中有一個為true，結果就為true。例如：(5 > 3) || (2 > 3)的結果是true。
（3）. !：邏輯非（NOT）運算子。用來反轉運算元的邏輯狀態。如果條件為true，則邏輯非運算子將使其為false。例如：!(5 > 3)的結果是false。

值得注意的是，Java中的&&和||運算子都具有"短路"行為。這意味著，如果左邊的運算元已經足夠確定整個表示式的值，那麼右邊的運算元就不會被計算。例如，在true || (x > y)表示式中，不論(x > y)的值是什麼，整個表示式的結果都是true，因此(x > y)不會被計算。同理，在false && (x > y)表示式中，(x > y)也不會被計算。這種特性可以用來防止程式中的某些計算產生副作用。

控制流語句

在Java中，if、for、while、switch等都是控制流語句，用於控制程式的執行流程。以下是他們的基本語法：

if語句：用於根據指定的條件執行程式碼。

if (condition) {
    // 程式碼塊1
} else if (anotherCondition) {
    // 程式碼塊2
} else {
    // 程式碼塊3
}

for迴圈：用於重複執行某段程式碼一定的次數。

for (initialization; condition; update) {
    // 程式碼塊
}

while迴圈：用於在滿足特定條件時重複執行程式碼。

while (condition) {
    // 程式碼塊
}

do...while迴圈：類似於while迴圈，但至少會執行一次程式碼塊。

do {
    // 程式碼塊
} while (condition);

switch語句：用於根據變數或表示式的值來執行特定的程式碼塊。

switch (expression) {
    case value1:
        // 程式碼塊1
        break;
    case value2:
        // 程式碼塊2
        break;
    default:
        // 程式碼塊3
}

請注意，這些控制流語句可以根據需要進行巢狀使用。

break語句用於完全結束迴圈，無論迴圈條件是否仍然為真。它通常用於提前退出迴圈。一旦break語句被執行，控制流將立即跳出當前的迴圈體，並繼續執行迴圈後面的語句。
continue語句用於跳過當前迴圈的剩餘部分，直接進入下一次迴圈。與break不同，continue並不會完全終止迴圈，它只是提前開始下一次迴圈。
break和continue都是用來改變迴圈的正常執行流程的。break用於完全退出迴圈，而continue用於跳過當前迴圈的剩餘部分並進入下一次迴圈。
輸入輸出：Java的標準輸入和輸出主要依賴於java.util.Scanner類和System類。

輸入

java.util.Scanner是一個簡單的文字掃描器，可以解析原始型別和字串的使用空格作為分隔符的文字。

以下是一個簡單的使用Scanner從標準輸入讀取資料的例子：

import java.util.Scanner; // 匯入Scanner類

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 建立一個新的Scanner物件，接收從標準輸入讀入的資料

        System.out.println("請輸入一個數字：");
        int number = scanner.nextInt(); // 讀取使用者輸入的整數

        System.out.println("你輸入的數字是：" + number);
    }
}

輸出

System.out是一個PrintStream型別的物件，它通常用於輸出文字資料到標準輸出（通常是控制檯）。

以下是使用System.out.println輸出資料的例子：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!"); // 輸出字串到標準輸出
    }
}

System.out.println可以接收各種型別的引數，包括字串、整數、浮點數等，它會將這些引數轉換為字串並輸出到標準輸出。如果你只是想輸出文字但不想在後面加上換行符，可以使用System.out.print方法。

陣列與字串

陣列

在Java中，陣列是同一型別資料的有序集合。

以下是Java陣列的主要知識點：

宣告陣列：在Java中，你可以使用以下語法宣告陣列：

dataType[] arrayName; // 宣告

例如，宣告一個整數陣列：

int[] myArray;

建立陣列：一旦陣列被宣告，你需要使用new關鍵字建立陣列：

arrayName = new dataType[arraySize]; // 建立

例如，建立一個可以儲存5個整數的陣列：

myArray = new int[5];

初始化陣列：你可以在宣告時就初始化陣列：

dataType[] arrayName = {element1, element2, element3, ...};

例如，宣告並初始化一個整數陣列：

int[] myArray = {1, 2, 3, 4, 5};

或者，你也可以在建立陣列後分別為每個元素賦值：

myArray[0] = 1;
myArray[1] = 2;

訪問陣列元素：你可以透過索引來訪問陣列元素：

arrayName[index]

例如，訪問陣列的第一個元素：

int firstElement = myArray[0];

陣列長度：你可以使用length屬性來獲取陣列的長度：

int length = arrayName.length;

例如，獲取陣列的長度：

int length = myArray.length;

遍歷陣列：你可以使用for迴圈或者for-each迴圈來遍歷陣列。例如：

for(int i=0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

for(int element : myArray) {
    System.out.println(element);
}

多維陣列：Java也支援多維陣列，最常見的是二維陣列：

int[][] my2DArray = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

這些是Java陣列的基本知識點。陣列是Java中非常重要的資料結構，用於儲存和操作大量同型別的資料。

基本的陣列操作，如初始化、訪問、修改元素、獲取陣列長度等，都是透過索引操作或者使用length屬性來完成的.

字串

在 Java 中，字串是一個非常常用的物件型別，用於儲存和操作文字。以下是 Java 字串的一些主要知識點：

建立字串：你可以使用雙引號 ("") 來建立一個字串字面量：

String str = "Hello, world!";

或者，你也可以使用 new 關鍵字來建立一個字串物件：

String str = new String("Hello, world!");

字串長度：你可以使用 length() 方法來獲取字串的長度：

int len = str.length();

連線字串：你可以使用 + 運算子或者 concat() 方法來連線兩個字串：

String str1 = "Hello";
String str2 = "world";
String str3 = str1 + " " + str2; // 使用 + 運算子
String str4 = str1.concat(" ").concat(str2); // 使用 concat() 方法

比較字串：你可以使用 equals() 方法或者 equalsIgnoreCase() 方法來比較兩個字串是否相等：

boolean isEqual = str1.equals(str2); // 區分大小寫
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2); // 不區分大小寫

字串子串：你可以使用 substring() 方法來獲取字串的子串：

String substr = str.substring(startIndex, endIndex); // 索引從 0 開始，包含開始索引，不包含結束索引

查詢字元或子串：你可以使用 indexOf() 方法或者 lastIndexOf() 方法來查詢字元或子串在字串中的位置：

int index = str.indexOf('o'); // 返回字元 'o' 第一次出現的位置
int lastIndex = str.lastIndexOf('o'); // 返回字元 'o' 最後一次出現的位置

替換字元或子串：你可以使用 replace() 方法來替換字串中的字元或子串：

String newStr = str.replace('o', 'a'); // 將所有的 'o' 替換為 'a'

字串分割：你可以使用 split() 方法來根據指定的分隔符分割字串：

String[] parts = str.split(" "); // 使用空格作為分隔符

字串轉換：你可以使用 toLowerCase()、toUpperCase() 方法來將字串轉換為小寫或大寫：

String lowerCaseStr = str.toLowerCase();
String upperCaseStr = str.toUpperCase();

異常處理

在Java中，異常是在程式執行期間發生的問題的物件表示。Java使用異常來表示錯誤，以便程式可以捕獲並處理它們。以下是Java異常的主要知識點：

異常型別：在Java中，所有的異常型別都是java.lang.Throwable類的子類。它有兩個主要的子類：java.lang.Error和java.lang.Exception。Error類表示的是程式無法處理的嚴重問題，如系統崩潰、虛擬機器錯誤等，程式通常不處理這類錯誤。Exception類表示的是程式可以處理的異常，它又分為兩種：檢查型異常（checked exceptions）和非檢查型異常（unchecked exceptions）。
丟擲異常：你可以使用throw關鍵字來丟擲一個異常。例如：

throw new Exception("This is an exception");

捕獲異常：你可以使用try-catch語句來捕獲並處理異常。例如：

try {
    // some code that may throw an exception
} catch (Exception e) {
    // handle the exception
    System.out.println(e.getMessage());
}

finally塊：finally塊包含的程式碼無論是否發生異常都會被執行，常用於資源的清理工作。例如：

try {
    // some code that may throw an exception
} catch (Exception e) {
    // handle the exception
} finally {
    // cleanup code here
}

自定義異常：你可以透過擴充套件Exception類（或其子類）來建立自定義的異常類。
異常鏈：你可以使用initCause()方法或者在建構函式中提供一個cause引數來設定一個異常的原因，這樣就可以形成一個異常鏈，它可以提供更詳細的錯誤資訊。

當Java中的程式碼丟擲一個異常時，程式的正常執行流程會被中斷，然後立即跳轉到匹配該異常型別的catch塊。

以下是具體的步驟：

當一個異常在try塊中被丟擲時，程式的控制權將立即轉移到第一個匹配該異常型別的catch塊。這意味著在異常被丟擲之後的try塊中的任何程式碼都不會被執行。
如果找到一個匹配的catch塊，那麼它的內部程式碼將被執行。這通常涉及到錯誤處理邏輯，例如記錄錯誤、清理資源、通知使用者等。
如果try/catch塊後面有finally塊，那麼不管是否捕獲到異常，finally塊中的程式碼都將被執行。這常用於資源的清理工作，例如關閉檔案、釋放記憶體等。
在所有的catch和finally塊執行完畢後，程式控制權將返回到try/catch/finally塊之後的程式碼，然後程式將繼續正常執行。
如果在try塊中丟擲的異常沒有被任何catch塊捕獲，那麼該異常將會被傳播到上一級方法中，如果上一級方法也沒有捕獲該異常，那麼該異常將繼續向上傳播，直到被捕獲或者達到程式的最頂層。如果一個異常到達了程式的最頂層還沒有被捕獲，那麼程式將會終止，並列印出異常的堆疊跟蹤資訊。

下面是一個例子，演示了異常的捕獲和處理：

try {
    int a = 5;
    int b = 0;
    int c = a / b; // This line will throw an ArithmeticException
    System.out.println(c);
} catch (ArithmeticException e) {
    System.out.println("An error occurred: " + e.getMessage());
} finally {
    System.out.println("This is the finally block.");
}

在這個例子中，當嘗試除以0時，將會丟擲一個ArithmeticException，這將中斷程式的正常執行流程，然後立即跳轉到catch塊。在catch塊中，程式列印出一個錯誤訊息。然後，不管是否發生了異常，finally塊中的程式碼都會被執行。

c#複習提綱
2018-06-22
C#
【期末考試季】JAVA進階複習提綱
2019-01-19
Java
計算機四級網路工程師複習提綱
2016-03-23
計算機工程師
醫學資訊學（3）——複習筆記提綱
2024-06-30
筆記
醫學資訊學（1）——複習筆記提綱
2024-06-30
筆記
醫學資訊學（2）——複習筆記提綱
2024-06-30
筆記
Java之美[從菜鳥到高手演變]之面試複習提綱
2014-04-13
Java面試
Python程式設計入門基礎語法詳解
2019-06-21
Python程式設計
實時音視訊技術入門提綱
2018-05-31
架構設計文件提綱簡描
2019-05-13
架構
JAVA NIO程式設計入門（二）
2019-02-23
Java程式設計
JAVA NIO程式設計入門（一）
2018-09-01
Java程式設計
JAVA NIO 程式設計入門（三）
2018-09-16
Java程式設計
java Swing程式設計入門
2018-03-22
Java程式設計
Windows 輸入法程式設計 (上) (轉)
2007-12-13
Windows程式設計
函數語言程式設計入門
2017-02-17
函數程式設計
Go語言程式設計快速入門
2024-06-02
Go程式設計
Python程式設計入門——基礎語法詳解（經典）
2018-12-05
Python程式設計
java入門之初讀___java程式設計思想
2011-01-14
Java程式設計
好程式設計師Java教程分享Java語法
2019-11-01
程式設計師Java
C、C++、Java到Python，程式設計入門學習什麼語言好?
2020-07-15
C++JavaPython程式設計
【資料結構】複習提綱與重難點概覽
2020-12-30
資料結構
Java入門之基礎程式設計
2022-03-31
Java程式設計
函數語言程式設計入門教程
2017-02-22
函數程式設計
傻瓜程式設計入門（C語言版）
2013-03-06
程式設計C語言
程式設計正規化 —— 函數語言程式設計入門
2019-02-16
程式設計函數
入門程式設計學習，適合學python語言嗎？
2020-11-10
程式設計Python
好程式設計師Java培訓分享如何快速入門Java程式設計
2020-04-29
程式設計師Java
java面試重要知識點複習大綱
2017-01-14
Java面試
入門MySQL——查詢語法練習
2020-06-23
MySql
程式設計入門之學哪種程式語言？
2022-02-25
程式設計
好程式設計師Java學習路線分享Redis快速入門
2019-09-20
程式設計師JavaRedis
Java語言入門：該如何學習Java
2021-01-22
Java
matlab:工科用程式設計入門語言
2015-10-25
Matlab程式設計
5.go語言函式提綱
2023-10-01
Go函式
史上最全shell指令碼程式設計語法上冊
2024-05-01
指令碼程式設計
JavaScript入門學習之旅(二)——JavaScript DOM程式設計藝術學習筆記(上)
2017-07-13
JavaScript程式設計筆記
Dart程式語言入門學習
2019-05-19
Dart