目錄

上：本文

• 基本語法與編譯運行

• 數(shù)據(jù)類型和關(guān)鍵字

• 常用語法

• 數(shù)組與字符串

• 異常處理

中：Java程序設(shè)計復(fù)習(xí)提綱（中：面向?qū)ο螅?- 孤飛 - 博客園 (cnblogs.com)

• 面向?qū)ο蠛皖?/li>

下：Java程序設(shè)計復(fù)習(xí)提綱（下：圖形界面） - 孤飛 - 博客園 (cnblogs.com)

• 圖形界面

基本語法與編譯運行

1. java沒有指針沒有全局變量
2. Java源代碼文件的后綴名是".java"。編譯后會生成一個或多個字節(jié)碼文件，后綴名為".class"。
3. Java的編譯器是javac，解釋器是java。使用javac編譯源代碼，然后用java運行編譯后的字節(jié)碼。
4. Java中的每一行代碼都需要以分號（;）結(jié)束。
5. Java語言對大小寫敏感，類名的首字母應(yīng)該大寫，而方法名應(yīng)該以小寫字母開頭。
6. Java的主方法（程序的入口點）的聲明應(yīng)為：public static void main(String args[])。

數(shù)據(jù)類型和關(guān)鍵字

1. package語句可以沒有，有的話必須放在文件開始的地方
2. public類每個文件中最多有一個
3. Java的注釋：單行注釋（//）、多行注釋（/*...*/）和文檔注釋（/**...*/），其中文檔注釋必須出現(xiàn)在公有類定義或公有方法頭前面，為將來的維護(hù)人員提供API
4. Java的true、false、null都是小寫的
5. Java源碼使用的是Unicode碼，而不是ASCII碼
6. 類名多為名詞，含有大小寫，首字母要求大寫；接口名的命名約定與類名相同
7. Java不允許用數(shù)字0,1表示邏輯值
8. Java數(shù)據(jù)類型：

? 另外字符數(shù)據(jù)還有string字符串。String類提供了許多用于操作字符串的方法，如連接字符串、比較字符串、查找子字符串等。

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

以下是一些例子：

char c = 'a'; // char類型

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

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

9. 0開頭表示8進(jìn)制數(shù)、0x表示16進(jìn)制數(shù)、077L表示長整型的8進(jìn)制數(shù)
10. Java類型轉(zhuǎn)換主要包括自動類型轉(zhuǎn)換（也叫隱式類型轉(zhuǎn)換）和強(qiáng)制類型轉(zhuǎn)換（也叫顯式類型轉(zhuǎn)換）：自動類型轉(zhuǎn)換是指從較小的數(shù)據(jù)類型自動轉(zhuǎn)換到較大的數(shù)據(jù)類型（如int轉(zhuǎn)為double）；而強(qiáng)制類型轉(zhuǎn)換則需要在表達(dá)式前顯式地加上要轉(zhuǎn)換的類型（如double轉(zhuǎn)為int，可能會導(dǎo)致精度丟失）。

double myDouble = 9.78;
int myInt = (int) myDouble;  // 強(qiáng)制類型轉(zhuǎn)換

11. 在Java中，可以使用四種訪問修飾符來修飾類和類的成員（如字段和方法）。這些訪問修飾符決定了其他類可以訪問的范圍。以下是這四種訪問修飾符（包括無修飾符，即默認(rèn)）的訪問權(quán)限：

    訪問權(quán)限	同一類	同一包中的子類	同一包中的非子類	不同包中的子類	不同包中的非子類
    無修飾符（默認(rèn)）	是	是	是	否	否
    private	是	否	否	否	否
    protected	是	是	是	是	否
    public	是	是	是	是	是

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

12. 類中定義的公有靜態(tài)變量相當(dāng)于全局變量。

13. 在Java中，"全局變量"這個術(shù)語通常不被使用，因為Java沒有像C或C++那樣的真正意義上的全局變量。然而，類中定義的公有靜態(tài)變量（public static variables）在某種意義上可以視為"全局變量"，因為它們可以在類的任何實例或者甚至在類的外部被訪問和修改。

    當(dāng)我們在一個類中聲明一個變量為public static時，這就意味著這個變量屬于這個類，而不是類的任何一個實例。這個變量在內(nèi)存中只有一個拷貝，所有的實例都共享這一個變量。

    public class MyClass {
        public static int count = 0;  // 公有靜態(tài)變量
    }
    

    在這個例子中，count就是一個公有靜態(tài)變量。我們可以在任何地方通過MyClass.count來訪問和修改這個變量，無論我們創(chuàng)建了多少個MyClass的實例。這就是為什么公有靜態(tài)變量在某種意義上可以視為"全局變量"。

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

14. void是一個關(guān)鍵字，用于指定一個方法不返回任何值。

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

15.在處理對象賦值這個問題上，Java和Python實際上有很多相似之處，因為它們都使用引用語義來處理對象。也就是說，當(dāng)你在Java或Python中將一個對象賦值給另一個變量時，你實際上是在復(fù)制對象的引用，而不是整個對象。這意味著賦值后的兩個變量指向的是同一個對象，對其中一個變量的任何修改都會影響到另一個變量。

然而，Java和Python在如何處理基本數(shù)據(jù)類型（如整數(shù)和浮點數(shù)）上有所不同：

• 在Java中，基本數(shù)據(jù)類型（如int，double等）不是對象，它們是直接存儲的值。當(dāng)你將一個基本類型的變量賦值給另一個變量時，Java會復(fù)制這個值，而不是引用。因此，修改一個變量不會影響到另一個變量。
• 而在Python中，所有的東西都是對象，包括整數(shù)和浮點數(shù)。這意味著當(dāng)你在Python中復(fù)制一個整數(shù)或浮點數(shù)時，你實際上是在復(fù)制一個引用。但是，因為Python中的數(shù)值類型是不可變的（即你不能修改它們的值），所以在實際使用中，這種差異通常不會引起問題。

在處理數(shù)組和其他容器類型時，這種差異就變得更加明顯了。例如，如果你在Java中復(fù)制一個數(shù)組，你會得到一個新的數(shù)組，它的元素是原數(shù)組的引用。如果你修改了新數(shù)組的元素，原數(shù)組也會被改變。但是，如果你在Python中復(fù)制一個列表，你會得到一個新的列表，它的元素是原列表的引用。如果你修改了新列表的元素，原列表不會被改變。這是因為在Python中，列表的賦值實際上是創(chuàng)建了一個新的列表對象，而這個新列表的元素是原列表的元素的引用。

在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是基本數(shù)據(jù)類型，所以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代碼中，我們首先創(chuàng)建了一個數(shù)值對象5并讓a引用它，然后讓b引用a引用的對象。然后我們創(chuàng)建了一個新的數(shù)值對象3并讓a引用它。Python的數(shù)值對象是不可變的，所以我們實際上是創(chuàng)建了一個新的數(shù)值對象，而不是修改了原來的數(shù)值對象。因此，改變a的引用并不會影響到b。所以最后，a的值為3，b的值仍為5。

總的來說，不論是在Java還是Python中，修改原始變量并不會影響到被賦值的變量。這是因為在這兩種語言中，數(shù)值賦值都是通過創(chuàng)建新的數(shù)值對象實現(xiàn)的，而不是直接修改原來的數(shù)值對象。

對于字符串結(jié)果也是一樣的。

16. 在Java中，成員變量（也稱為字段、屬性或?qū)嵗兞浚┖挽o態(tài)變量會有默認(rèn)初始化，而局部變量則必須顯式初始化才能使用。

• 成員變量和靜態(tài)變量：如果你在類中聲明一個字段但沒有給它賦值，Java會為其提供一個默認(rèn)值。具體默認(rèn)值取決于字段的數(shù)據(jù)類型。例如，數(shù)字類型的默認(rèn)值是0，布爾類型的默認(rèn)值是false，引用類型（類、接口等）的默認(rèn)值是null。
• 局部變量：這是在方法、構(gòu)造函數(shù)或者代碼塊中定義的變量。局部變量在使用前必須顯式初始化，否則編譯器將報錯。這是因為局部變量存儲在棧上，而不是像成員變量和靜態(tài)變量那樣存儲在堆上，Java不會為棧上的變量提供默認(rèn)值。

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

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

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

public class Main {
    public static void main(String[] args) {
        int a = 5; // 這是一個局部變量
        System.out.println(a); // 輸出：5
    }
}

常用語法

1. 邏輯運算符

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

（1）. &&：邏輯與（AND）運算符。當(dāng)且僅當(dāng)兩個操作數(shù)都為true時，結(jié)果才為true。例如：(5 > 3) && (2 > 3)的結(jié)果是false。
（2）. ||：邏輯或（OR）運算符。只要兩個操作數(shù)中有一個為true，結(jié)果就為true。例如：(5 > 3) || (2 > 3)的結(jié)果是true。
（3）. !：邏輯非（NOT）運算符。用來反轉(zhuǎn)操作數(shù)的邏輯狀態(tài)。如果條件為true，則邏輯非運算符將使其為false。例如：!(5 > 3)的結(jié)果是false。

值得注意的是，Java中的&&和||運算符都具有"短路"行為。這意味著，如果左邊的操作數(shù)已經(jīng)足夠確定整個表達(dá)式的值，那么右邊的操作數(shù)就不會被計算。例如，在true || (x > y)表達(dá)式中，不論(x > y)的值是什么，整個表達(dá)式的結(jié)果都是true，因此(x > y)不會被計算。同理，在false && (x > y)表達(dá)式中，(x > y)也不會被計算。這種特性可以用來防止程序中的某些計算產(chǎn)生副作用。

2. 控制流語句

在Java中，if、for、while、switch等都是控制流語句，用于控制程序的執(zhí)行流程。以下是他們的基本語法：

• if語句：用于根據(jù)指定的條件執(zhí)行代碼。

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

• for循環(huán)：用于重復(fù)執(zhí)行某段代碼一定的次數(shù)。

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

• while循環(huán)：用于在滿足特定條件時重復(fù)執(zhí)行代碼。

while (condition) {
    // 代碼塊
}

• do...while循環(huán)：類似于while循環(huán)，但至少會執(zhí)行一次代碼塊。

do {
    // 代碼塊
} while (condition);

• switch語句：用于根據(jù)變量或表達(dá)式的值來執(zhí)行特定的代碼塊。

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

請注意，這些控制流語句可以根據(jù)需要進(jìn)行嵌套使用。

3. break語句用于完全結(jié)束循環(huán)，無論循環(huán)條件是否仍然為真。它通常用于提前退出循環(huán)。一旦break語句被執(zhí)行，控制流將立即跳出當(dāng)前的循環(huán)體，并繼續(xù)執(zhí)行循環(huán)后面的語句。
   continue語句用于跳過當(dāng)前循環(huán)的剩余部分，直接進(jìn)入下一次循環(huán)。與break不同，continue并不會完全終止循環(huán)，它只是提前開始下一次循環(huán)。
   break和continue都是用來改變循環(huán)的正常執(zhí)行流程的。break用于完全退出循環(huán)，而continue用于跳過當(dāng)前循環(huán)的剩余部分并進(jìn)入下一次循環(huán)。

4. 輸入輸出：Java的標(biāo)準(zhǔn)輸入和輸出主要依賴于java.util.Scanner類和System類。

輸入

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

以下是一個簡單的使用Scanner從標(biāo)準(zhǔn)輸入讀取數(shù)據(jù)的例子：

import java.util.Scanner; // 導(dǎo)入Scanner類

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 創(chuàng)建一個新的Scanner對象，接收從標(biāo)準(zhǔn)輸入讀入的數(shù)據(jù)

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

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

輸出

System.out是一個PrintStream類型的對象，它通常用于輸出文本數(shù)據(jù)到標(biāo)準(zhǔn)輸出（通常是控制臺）。

以下是使用System.out.println輸出數(shù)據(jù)的例子：

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

System.out.println可以接收各種類型的參數(shù)，包括字符串、整數(shù)、浮點數(shù)等，它會將這些參數(shù)轉(zhuǎn)換為字符串并輸出到標(biāo)準(zhǔn)輸出。如果你只是想輸出文本但不想在后面加上換行符，可以使用System.out.print方法。

數(shù)組與字符串

數(shù)組

在Java中，數(shù)組是同一類型數(shù)據(jù)的有序集合。

以下是Java數(shù)組的主要知識點：

1. 聲明數(shù)組：在Java中，你可以使用以下語法聲明數(shù)組：

dataType[] arrayName; // 聲明

例如，聲明一個整數(shù)數(shù)組：

int[] myArray;

2. 創(chuàng)建數(shù)組：一旦數(shù)組被聲明，你需要使用new關(guān)鍵字創(chuàng)建數(shù)組：

arrayName = new dataType[arraySize]; // 創(chuàng)建

例如，創(chuàng)建一個可以存儲5個整數(shù)的數(shù)組：

myArray = new int[5];

3. 初始化數(shù)組：你可以在聲明時就初始化數(shù)組：

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

例如，聲明并初始化一個整數(shù)數(shù)組：

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

或者，你也可以在創(chuàng)建數(shù)組后分別為每個元素賦值：

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

4. 訪問數(shù)組元素：你可以通過索引來訪問數(shù)組元素：

arrayName[index]

例如，訪問數(shù)組的第一個元素：

int firstElement = myArray[0];

5. 數(shù)組長度：你可以使用length屬性來獲取數(shù)組的長度：

int length = arrayName.length;

例如，獲取數(shù)組的長度：

int length = myArray.length;

6. 遍歷數(shù)組：你可以使用for循環(huán)或者for-each循環(huán)來遍歷數(shù)組。例如：

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

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

7. 多維數(shù)組：Java也支持多維數(shù)組，最常見的是二維數(shù)組：

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

這些是Java數(shù)組的基本知識點。數(shù)組是Java中非常重要的數(shù)據(jù)結(jié)構(gòu)，用于存儲和操作大量同類型的數(shù)據(jù)。

基本的數(shù)組操作，如初始化、訪問、修改元素、獲取數(shù)組長度等，都是通過索引操作或者使用length屬性來完成的.

字符串

在 Java 中，字符串是一個非常常用的對象類型，用于存儲和操作文本。以下是 Java 字符串的一些主要知識點：

1. 創(chuàng)建字符串：你可以使用雙引號 ("") 來創(chuàng)建一個字符串字面量：

String str = "Hello, world!";

或者，你也可以使用 new 關(guān)鍵字來創(chuàng)建一個字符串對象：

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

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

int len = str.length();

3. 連接字符串：你可以使用 + 運算符或者 concat() 方法來連接兩個字符串：

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

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

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

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

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

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

int index = str.indexOf('o'); // 返回字符 'o' 第一次出現(xiàn)的位置
int lastIndex = str.lastIndexOf('o'); // 返回字符 'o' 最后一次出現(xiàn)的位置

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

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

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

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

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

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

異常處理

在Java中，異常是在程序執(zhí)行期間發(fā)生的問題的對象表示。Java使用異常來表示錯誤，以便程序可以捕獲并處理它們。以下是Java異常的主要知識點：

1. 異常類型：在Java中，所有的異常類型都是java.lang.Throwable類的子類。它有兩個主要的子類：java.lang.Error和java.lang.Exception。Error類表示的是程序無法處理的嚴(yán)重問題，如系統(tǒng)崩潰、虛擬機(jī)錯誤等，程序通常不處理這類錯誤。Exception類表示的是程序可以處理的異常，它又分為兩種：檢查型異常（checked exceptions）和非檢查型異常（unchecked exceptions）。

2. 拋出異常：你可以使用throw關(guān)鍵字來拋出一個異常。例如：

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

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

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

4. finally塊：finally塊包含的代碼無論是否發(fā)生異常都會被執(zhí)行，常用于資源的清理工作。例如：

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

5. 自定義異常：你可以通過擴(kuò)展Exception類（或其子類）來創(chuàng)建自定義的異常類。

6. 異常鏈：你可以使用initCause()方法或者在構(gòu)造函數(shù)中提供一個cause參數(shù)來設(shè)置一個異常的原因，這樣就可以形成一個異常鏈，它可以提供更詳細(xì)的錯誤信息。

當(dāng)Java中的代碼拋出一個異常時，程序的正常執(zhí)行流程會被中斷，然后立即跳轉(zhuǎn)到匹配該異常類型的catch塊。

以下是具體的步驟：

1. 當(dāng)一個異常在try塊中被拋出時，程序的控制權(quán)將立即轉(zhuǎn)移到第一個匹配該異常類型的catch塊。這意味著在異常被拋出之后的try塊中的任何代碼都不會被執(zhí)行。

2. 如果找到一個匹配的catch塊，那么它的內(nèi)部代碼將被執(zhí)行。這通常涉及到錯誤處理邏輯，例如記錄錯誤、清理資源、通知用戶等。

3. 如果try/catch塊后面有finally塊，那么不管是否捕獲到異常，finally塊中的代碼都將被執(zhí)行。這常用于資源的清理工作，例如關(guān)閉文件、釋放內(nèi)存等。

4. 在所有的catch和finally塊執(zhí)行完畢后，程序控制權(quán)將返回到try/catch/finally塊之后的代碼，然后程序?qū)⒗^續(xù)正常執(zhí)行。

5. 如果在try塊中拋出的異常沒有被任何catch塊捕獲，那么該異常將會被傳播到上一級方法中，如果上一級方法也沒有捕獲該異常，那么該異常將繼續(xù)向上傳播，直到被捕獲或者達(dá)到程序的最頂層。如果一個異常到達(dá)了程序的最頂層還沒有被捕獲，那么程序?qū)K止，并打印出異常的堆棧跟蹤信息。

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

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.");
}

在這個例子中，當(dāng)嘗試除以0時，將會拋出一個ArithmeticException，這將中斷程序的正常執(zhí)行流程，然后立即跳轉(zhuǎn)到catch塊。在catch塊中，程序打印出一個錯誤消息。然后，不管是否發(fā)生了異常，finally塊中的代碼都會被執(zhí)行。文章來源地址http://www.zghlxwxcb.cn/news/detail-449540.html

到了這里，關(guān)于Java程序設(shè)計復(fù)習(xí)提綱（上：入門語法）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！