我的個人博客主頁：如果’'真能轉義1??說1??的博客主頁
關于Java基本語法學習---->可以參考我的這篇博客：《我在VScode學Java》

伍._. 顯式參數(shù)和隱式參數(shù)：

在Java中，顯式參數(shù)和隱式參數(shù)是方法調用中的兩種不同類型的參數(shù)。

1. 顯式參數(shù)（Explicit Parameters）：提供了方法執(zhí)行所需的具體值。

它們是在方法調用時明確傳遞給方法的參數(shù)。
	參數(shù)在表達式中以逗號分隔，并且要與方法定義中的形式參數(shù)匹配。

public class ExplicitParametersExample {
 
    // 方法定義中的形式參數(shù)為 x 和 y
    public static int sum(int x, int y) {
        return x + y;
    }

    public static void main(String[] args) {
        int a = 5;
        int b = 10;

        // 顯式參數(shù) 5 和 10 被傳遞給 sum 方法
        int result = sum(a, b);

        System.out.println("Sum: " + result);
    }
}

注釋：

• 第7行：sum 方法的參數(shù) x 和 y 是顯式參數(shù)。
• 第13行：sum(a, b) 中的 a 和 b 是顯式參數(shù)，它們被傳遞給 sum 方法進行求和操作。

解釋：
在上述示例中，sum 方法接收兩個顯式參數(shù)，將它們相加并返回結果。在 main 方法中，我們定義了變量 a 和 b 并賦予它們具體的值。然后，我們調用 sum 方法并將變量 a 和 b 作為顯式參數(shù)傳遞給該方法。在方法內部，這些顯式參數(shù)被用于執(zhí)行求和操作，并將結果存儲在 result 變量中。最后，打印出結果。

2. 隱式參數(shù)（Implicit Parameters）：

它們是非顯式傳遞給方法的參數(shù)，通常是指對象或類上下文中的成員變量或方法。
隱式參數(shù)不需要在方法調用表達式中顯式提供，而是通過對象或類來訪問。

public class ImplicitParametersExample {

    private int value; // 隱式參數(shù)

    public void setValue(int newValue) {
        this.value = newValue;
    }

    public int getValue() {
        return value;
    }

    public static void main(String[] args) {
        ImplicitParametersExample example = new ImplicitParametersExample();

        example.setValue(42); // 隱式參數(shù)使用

        int result = example.getValue();
        System.out.println("Value: " + result);
    }
}

注釋：

• 第3行：value 是一個隱式參數(shù)，它是類 ImplicitParametersExample 的成員變量。
• 第5行：setValue 方法接收一個隱式參數(shù) newValue，并將其賦值給隱式參數(shù) value。
• 第8行：getValue 方法返回隱式參數(shù) value 的值。

解釋：在上述示例中，我們創(chuàng)建了一個類 ImplicitParametersExample，它包含一個隱式參數(shù) value，表示某個對象的特定值。在 main 方法中，我們創(chuàng)建了一個類的實例 example，然后通過調用 setValue 方法隱式地傳遞參數(shù)給隱式參數(shù) value。接著，調用 getValue 方法來獲取隱式參數(shù) value 的值，并將其打印出來。

關鍵字 this 指示隱式參數(shù)

在Java中，關鍵字 this 用于指示隱式參數(shù)，而不是作為隱式參數(shù)本身。隱式參數(shù)通常是指對象或類上下文中的成員變量或方法。

在示例代碼中，value 是一個隱式參數(shù)，它是類 ImplicitParametersExample 的成員變量。通過使用 this 關鍵字，我們可以訪問隱式參數(shù) value 并將其賦值為 newValue。所以，this.value = newValue; 是在使用隱式參數(shù) value 來更新其值的操作。

總結：顯式參數(shù)是在方法調用時明確傳遞的參數(shù)，而隱式參數(shù)是不需要顯式提供，通過對象或類來訪問的參數(shù)（通常是成員變量或方法）。

陸._.靜態(tài)方法：

Java的靜態(tài)方法是定義在類中的一種特殊類型的方法。

靜態(tài)方法與類本身相關，而不是與類的實例相關?？梢酝ㄟ^類名直接調用靜態(tài)方法，而無需創(chuàng)建類的實例。

以下是定義靜態(tài)方法的格式：

access_modifier static return_type method_name(parameter_list) {
    // 方法體
}

其中：

• access_modifier 表示訪問修飾符，可以是 public、private、protected 或默認的訪問修飾符。
• static 關鍵字表示該方法是靜態(tài)方法。
• return_type 表示方法返回的數(shù)據(jù)類型，可以是基本類型或引用類型，如果方法不返回任何值，則使用 void。
• method_name 是方法的名稱，按照命名規(guī)范進行命名。
• parameter_list 是方法的參數(shù)列表，包含參數(shù)的類型和名稱。

靜態(tài)方法的使用：

1. 可以通過類名直接調用靜態(tài)方法，例如：ClassName.methodName(arguments)。
2. 在靜態(tài)方法內部，只能調用類中定義的其他靜態(tài)成員（包括靜態(tài)變量和其他靜態(tài)方法），不能訪問非靜態(tài)成員（實例變量或實例方法）。

適用范圍：常用于工具類中的公共方法

• 靜態(tài)方法，這些方法與類的實例狀態(tài)無關，主要用于提供通用的功能。

注意事項：

• 由于靜態(tài)方法不依賴于對象的狀態(tài)，因此無法直接訪問實例變量或實例方法。如果需要訪問這些實例成員，可以通過創(chuàng)建類的實例來實現(xiàn)。
• 靜態(tài)方法無法被覆蓋（override），子類只能隱藏父類的靜態(tài)方法。
• 靜態(tài)方法不能使用 this 關鍵字，因為 this 指向當前對象，而靜態(tài)方法與對象無關。
• 靜態(tài)方法可以在沒有創(chuàng)建對象的情況下調用，但是在某些情況下，可能會影響應用程序的設計和結構，所以應該謹慎使用靜態(tài)方法。

總結：靜態(tài)方法是類級別的方法，可以通過類名直接調用，適用于提供通用的功能實現(xiàn)，但由于無法直接訪問實例成員，使用時需注意上述事項。

要調用靜態(tài)方法，你可以使用類名直接調用，而不需要創(chuàng)建類的實例。例如，在其他類中調用staticMethod()，可以使用以下代碼：

Studentsss.staticMethod();
要調用返回char數(shù)組的方法printstu()，你需要首先創(chuàng)建Studentsss類的實例，然后使用該實例調用方法。例如：

Studentsss student = new Studentsss();
char[] result = student.printstu();
請注意，由于printstu()方法返回null，所以result變量將包含null值。你可以根據(jù)需要修改printstu()方法的實現(xiàn)，以返回所需的結果。

Main方法是一種特殊的靜態(tài)方法?！?gt;其不對任何對象操作。實際中，程序啟動還沒有任何對象

在類中寫main

package work629;

class BOOK {
    private String author;
    private String title;
    private double price;
    private String publisher;
    private int publishedYear;

    public BOOK() {
    }

    public BOOK(String author, String title, double price, String publisher, int i) {
        this.author = author;
        this.title = title;
        this.price = price;
        this.publisher = publisher;
        this.publishedYear = i;
    }

    public String getAuthor() {
        return this.author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return this.price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getPublisher() {
        return this.publisher;
    }

    public void setPublisher(String publisher) {
        this.publisher = publisher;
    }

    public int getPublishedYear() {
        return this.publishedYear;
    }

    public void setPublishedYear(int publishedYear) {
        this.publishedYear = publishedYear;
    }

    public void showDisplayBook() {
        System.out.println("Author: " + this.author);
        System.out.println("Title: " + this.title);
        System.out.println("Price: " + this.price);
        System.out.println("Publisher: " + this.publisher);
        System.out.println("Published Year: " + this.publishedYear);
    }

    public static void main(String[] args) {
        BOOK book123 = new BOOK("21", "32", 12, "32", 123);
        book123.showDisplayBook();
    }
}

分開為：類 + 測試類

柒._. 在Java中，有四種訪問修飾符：

1. public：公共的訪問修飾符，可以被任何類訪問。如果一個類、方法或者變量使用了public修飾符，那么它們可以被任何其他類訪問。

2. protected：受保護的訪問修飾符，可以被同一包內的其他類訪問，以及該類的子類訪問（不管是否在同一包內）。protected修飾符用于實現(xiàn)繼承以及提供對相關類的一定程度的訪問控制。

3. default（默認）：如果沒有指定訪問修飾符，即沒有使用public、protected或private修飾符，那么該成員（類、方法或者變量）被默認為default訪問修飾符。default修飾符允許同一包中的其他類訪問。

4. private：私有的訪問修飾符，只能在同一類內訪問，其他類無法訪問私有成員。private修飾符主要用于實現(xiàn)封裝，限制外部對類的訪問，隱藏類內部的實現(xiàn)細節(jié)。

這些訪問修飾符可應用于類，類的成員變量和方法，用于控制對類及其成員的訪問級別，并確保良好的封裝性和訪問性。使用適當?shù)脑L問修飾符可以提高代碼的可維護性和安全性。

【 1 】代碼：

1. 代碼示例：使用public訪問修飾符

public class Circle {
    public double radius;

    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.radius = 5.0;
        double area = circle.calculateArea();
        System.out.println("Area of the circle: " + area);
    }
}

好處：

• 其他類可以直接訪問Circle類的radius屬性和calculateArea方法，無需通過中間層或者getter/setter方法來訪問。
• 允許其他類實例化Circle對象并調用其公共方法，以便執(zhí)行相應的計算操作。

2. 代碼示例：使用private訪問修飾符

public class BankAccount {
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient balance");
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456789", 1000.0);
        account.deposit(500.0);
        account.withdraw(200.0);
        double balance = account.getBalance();
        System.out.println("Current balance: " + balance);
    }
}

好處：

• 通過將賬戶號碼和余額設置為私有屬性，可以防止其他類直接修改這些敏感信息，確保了數(shù)據(jù)的安全性。
• 只允許通過公共方法進行存款、取款以及查詢余額等操作，提供了更好的封裝性和可控制性。
• 可以在公共方法中進行邏輯驗證，例如檢查是否有足夠的余額進行取款，從而保證了代碼的正確性和可靠性。

3. 代碼示例：使用protected訪問修飾符

package com.example;

public class Shape {
    protected double area;

    protected void calculateArea() {
        // 計算面積的具體實現(xiàn)
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        calculateArea();
        return area;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        double area = circle.getArea();
        System.out.println("Area of the circle: " + area);
    }
}

好處：

• 在Shape類中，將area屬性和calculateArea方法設置為protected，這意味著它們可以被Circle類（在同一包中）繼承并訪問。
• Circle類可以通過調用getArea方法來獲取圓形的面積，而無需了解具體的計算過程。這樣可以隱藏計算的細節(jié)并提高代碼的抽象性和可重用性。

4. 代碼示例：使用default訪問修飾符

package com.example;

class Person {
    String name;
    int age;
    
    void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "John";
        person.age = 25;
        person.displayInfo();
    }
}

好處：

• 在Person類中，沒有指定任何訪問修飾符（使用默認修飾符），這意味著該類只能在同一包中被訪問和實例化。
• 主類Main在同一個包中，可以創(chuàng)建Person對象并訪問其屬性和方法。但是在其他包中是無法訪問Person類的，從而提供了一定程度的封裝和隱藏性。

這些示例展示了不同訪問修飾符的具體用法以及它們帶來的好處。通過合理選擇適當?shù)脑L問修飾符，可以控制代碼的可見性、封裝性和可維護性，實現(xiàn)良好的代碼組織和管理。

【 2 】訪問修飾符的存在是為了實現(xiàn)封裝性和訪問控制，以及提供對代碼的良好組織和管理。以下是一些使用多種訪問修飾符的原因：

1. 封裝性：通過將成員變量和方法設置為private，可以隱藏類的內部實現(xiàn)細節(jié)，防止其他類直接訪問和修改這些成員，從而確保數(shù)據(jù)的安全性和一致性。

2. 訪問控制：訪問修飾符允許我們控制不同類之間的訪問權限。public修飾符可以使得類的成員可被其他類訪問，protected修飾符可以在繼承關系中提供受限制的訪問，default修飾符允許同一包中的其他類訪問，并且private修飾符僅允許同一類內的訪問。

3. 模塊化設計：訪問修飾符有助于將代碼劃分為模塊，每個模塊可以有不同的訪問級別。這種模塊化設計使得代碼更易于理解、維護和重用。

4. 安全性和可靠性：通過限制對某些類成員的訪問，可以減少錯誤和意外修改的可能性。只有有限的訪問權限可以幫助我們保護重要的數(shù)據(jù)和方法，以確保代碼的正確性和可靠性。

總之，訪問修飾符的規(guī)定使得我們能夠更好地控制代碼的訪問級別和使用范圍，從而增強代碼的封裝性、安全性和可維護性。通過合理地選擇適當?shù)脑L問修飾符，可以組織和管理代碼，并提供良好的編程實踐。

【 3 】注意事項：

盡管訪問修飾符在代碼中有很多好處，但它們也可能帶來一些潛在的壞處。以下是一些可能的問題：

1. 過度暴露：使用public修飾符可能導致過度暴露類、方法或變量。如果不加限制地公開所有成員，其他類可能會直接訪問和修改這些成員，從而破壞了封裝性和數(shù)據(jù)的一致性。

2. 過于限制：在某些情況下，過度使用private或protected修飾符可能會過于限制其他類對相關成員的訪問。這可能導致其他類無法正常使用或擴展該類，從而降低了代碼的可重用性和靈活性。

3. 耦合性增加：當一個類使用了過多的protected成員時，它與其他繼承它的子類之間可能產生緊密的耦合關系。這種緊密的耦合關系可能導致對基類的修改影響到子類的實現(xiàn)，從而增加了維護和擴展的難度。

4. 可見性混亂：過多使用不同的訪問修飾符可能導致代碼的可見性變得混亂。特別是在大型項目中，過多的public、protected、default和private修飾符可能使得類之間的關系變得復雜，使代碼難以理解和維護。

5. 安全性風險：如果不正確地選擇訪問修飾符，可能會引入安全性風險。例如，將某些敏感信息設置為public或default訪問修飾符，可能導致其他類或惡意用戶直接訪問和修改這些信息。

需要權衡和合理選擇適當?shù)脑L問修飾符，以確保代碼具有適當?shù)姆庋b性、可維護性和安全性。遵循良好的設計原則和最佳實踐，可以避免潛在的問題并提高代碼質量。

捌 ._. static關鍵字：當在Java中使用 static 關鍵字時，它可以被用于方法、變量和內部類。下面將一步步地講解 static 關鍵字的不同用法。

1. 靜態(tài)變量（Static Variables） --> 在Java中，靜態(tài)變量必須在類的作用域內聲明，而不能在方法內部聲明。

調用方式:
	對象名調用
	類名調用(推薦)

靜態(tài)變量是被聲明為 static 的成員變量。它們屬于類而不是實例化對象，并且在整個類的所有實例之間共享相同的值。靜態(tài)變量可以通過使用類名稱直接訪問，而不需要創(chuàng)建類的實例。

public class MyClass {
    static int myStaticVariable = 10;
    // ...
}

在上面的例子中，myStaticVariable 是一個靜態(tài)變量，可以使用 MyClass.myStaticVariable 來訪問它。

[ 1 ]錯誤提示：

[ 2 ]靜態(tài)變量和實例變量是Java中兩種不同類型的變量，它們之間有以下區(qū)別：

1. 作用域：

• 靜態(tài)變量（static variables）屬于整個類，而不是類的實例。它們在類加載時被初始化，并且在整個類的所有實例之間共享相同的值。
• 實例變量（instance variables）屬于類的每個實例化對象。每個對象都有自己的實例變量副本，它們在對象創(chuàng)建時初始化。

2. 訪問方式：

• 靜態(tài)變量可以通過類名直接訪問，無需創(chuàng)建類的實例。（< 1 >在類的內部，可以在任何方法內直接訪問靜態(tài)變量；< 2 >在其他類中，可以通過類名訪問該類中的靜態(tài)變量。）例如：ClassName.staticVariable。
• 實例變量需要通過創(chuàng)建類的實例才能訪問。（< 1 >在類的內部，可以在非靜態(tài)方法中直接訪問實例變量。< 2 >在本類的靜態(tài)方法或其他類中則需要通過類的實例對象進行訪問。）例如：objectName.instanceVariable。

3. 生命周期：

• 靜態(tài)變量在類加載時初始化，并且在整個程序執(zhí)行期間一直存在，直到程序終止。
• 實例變量在對象創(chuàng)建時初始化，當對象不再被引用時，它們的內存會被垃圾回收器釋放。

4. 內存占用：

• 靜態(tài)變量位于方法區(qū)（Method Area），只有一個副本。（所有實例都包含一個相同的常量屬性，可以把這個屬性定義為靜態(tài)常量類型，從而節(jié)省內存空間）
• 實例變量位于堆內存中的每個對象實例中，每個對象都有自己的副本。

5. 使用場景：

• 靜態(tài)變量適合保存與類相關的常量或需要在多個實例之間共享的數(shù)據(jù)。(靜態(tài)變量可以被類的所有實例共享，因此靜態(tài)變量可以作為實例之間的共享數(shù)據(jù)，增強實例之間的交互性。)
• 實例變量適合保存對象的特定狀態(tài)和屬性。

下面是一個示例，演示了靜態(tài)變量和實例變量的使用：

public class MyClass {
    static int staticVariable;
    int instanceVariable;

    public static void main(String[] args) {
        // 靜態(tài)變量訪問
        MyClass.staticVariable = 10;

        // 創(chuàng)建類的實例
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();

        // 實例變量訪問
        obj1.instanceVariable = 20;
        obj2.instanceVariable = 30;
    }
}

在上面的示例中，staticVariable 是一個靜態(tài)變量，可以通過類名直接訪問。instanceVariable 是一個實例變量，需要通過創(chuàng)建類的實例來訪問。

2. 靜態(tài)方法（Static Methods）

調用方式:
	對象名調用
	類名調用(推薦)

靜態(tài)方法是用 static 關鍵字修飾的方法。與靜態(tài)變量類似，靜態(tài)方法也屬于類而不是實例化對象。它們可以通過類名直接調用，無需實例化對象。

public class MyClass {
    public static void myStaticMethod() {
        // 靜態(tài)方法的實現(xiàn)
    }
    // ...
}

在上面的例子中，myStaticMethod() 是一個靜態(tài)方法，可以通過 MyClass.myStaticMethod() 進行調用。

[ 1 ]在使用靜態(tài)方法時，需要注意以下幾點：

1. 靜態(tài)方法是屬于類的，而不是類的實例。因此，可以通過類名直接調用靜態(tài)方法，而無需創(chuàng)建類的實例。

2. 靜態(tài)方法不能訪問類的非靜態(tài)成員，如實例變量和非靜態(tài)方法。它們只能訪問靜態(tài)成員，包括靜態(tài)變量和其他靜態(tài)方法。

3. 靜態(tài)方法中不能使用關鍵字"this"，因為"this"代表當前對象的引用，而靜態(tài)方法沒有特定的對象實例。

4. 靜態(tài)方法在整個程序運行期間都存在，因此適合用于定義一些工具方法或公共方法，不依賴于對象的狀態(tài)或實例化。

5. 靜態(tài)方法可以被子類繼承和隱藏，但不能被子類重寫。如果在子類中定義了與父類同名的靜態(tài)方法，那么父類中的靜態(tài)方法會被隱藏。

下面是一些關于類和沒有類的代碼示例：

1. 類的代碼示例：

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }
}

// 調用類的靜態(tài)方法
int sum = MathUtils.add(3, 5);
System.out.println(sum); // 輸出：8

2. 沒有類的代碼示例（靜態(tài)方法在類外部）：

public class Main {
    public static void main(String[] args) {
        int result = Calculator.add(3, 5);
        System.out.println(result); // 輸出：8
    }
}

// 定義靜態(tài)方法
class Calculator {
    public static int add(int a, int b) {
        return a + b;
    }
}

請注意，以上示例僅用于說明靜態(tài)方法的使用方法，并非完整的可運行代碼。具體的代碼實現(xiàn)可能需要更多的上下文和邏輯。

[ 2 ]靜態(tài)方法和實例方法在使用上有以下幾個區(qū)別：

1. 訪問方式：

   • 靜態(tài)方法可以通過類名直接調用，無需創(chuàng)建類的實例。
   • 實例方法需要通過對象實例調用，必須先創(chuàng)建類的實例。

2. 調用對象：

   • 靜態(tài)方法沒有特定的對象實例，因此不能訪問實例變量或使用關鍵字"this"。
   • 實例方法是針對具體對象實例的操作，可以訪問實例變量，并且可以使用關鍵字"this"引用當前對象。

3. 內存分配：

   • 靜態(tài)方法在程序運行期間一直存在于內存中，不依賴于對象的狀態(tài)或實例化。
   • 實例方法需要在對象創(chuàng)建時分配內存，并且必須通過對象實例才能調用。

4. 繼承和重寫：

   • 靜態(tài)方法可以被子類繼承和隱藏，但不能被子類重寫。
   • 實例方法可以被子類繼承、重寫和覆蓋。

5. 訪問權限：

   • 靜態(tài)方法可以設置為public、protected、private等訪問修飾符，控制其可見性。
   • 實例方法也可以設置為public、protected、private等訪問修飾符，同時還可以使用默認訪問修飾符（沒有修飾符），在同一包內可見。

需要注意的是，靜態(tài)方法適用于不依賴對象實例的操作，一般用于定義工具方法或公共方法；而實例方法適用于需要操作對象實例的行為。選擇使用靜態(tài)方法還是實例方法要根據(jù)具體的業(yè)務需求和設計目的來確定。

3. 靜態(tài)代碼塊（Static Blocks）

靜態(tài)代碼塊是在類加載過程中執(zhí)行的一段代碼塊，用于對靜態(tài)成員進行初始化操作或執(zhí)行一些其他靜態(tài)的預處理工作。靜態(tài)代碼塊在類第一次被加載的時候執(zhí)行，并且只會執(zhí)行一次。

靜態(tài)代碼塊的定義格式如下：

static {
    // 靜態(tài)代碼塊的代碼邏輯
}

靜態(tài)代碼塊使用關鍵字static來修飾，后跟一對花括號{}包裹起來的代碼塊。在靜態(tài)代碼塊內部可以編寫任意的 Java 代碼，用于完成相關的初始化或預處理操作。

靜態(tài)代碼塊的特點如下：

• 靜態(tài)代碼塊在類加載時自動執(zhí)行，只執(zhí)行一次。
• 靜態(tài)代碼塊的執(zhí)行順序與其在源代碼中的位置有關，先定義的靜態(tài)代碼塊先執(zhí)行。
• 靜態(tài)代碼塊不能接受傳遞給構造函數(shù)的參數(shù)，因為它不是用于創(chuàng)建對象實例的，而是在類加載過程中執(zhí)行的。

靜態(tài)代碼塊常見的應用包括：

• 初始化靜態(tài)變量：可以在靜態(tài)代碼塊中對靜態(tài)變量進行賦值或計算。
• 執(zhí)行一次性的靜態(tài)預處理工作：比如加載配置文件、注冊驅動程序等。

以下是一個靜態(tài)代碼塊的示例：

public class MyClass {
    static {
        System.out.println("靜態(tài)代碼塊執(zhí)行");
        // 一些初始化操作或預處理工作
    }

    public static void main(String[] args) {
        System.out.println("主方法執(zhí)行");
        // 主方法中的其他代碼
    }
}

輸出結果：

靜態(tài)代碼塊執(zhí)行
主方法執(zhí)行

在上述示例中，靜態(tài)代碼塊在類第一次被加載時執(zhí)行，輸出"靜態(tài)代碼塊執(zhí)行"。然后，調用了主方法，輸出"主方法執(zhí)行"。注意，靜態(tài)代碼塊只會執(zhí)行一次，不會因為創(chuàng)建對象實例而再次執(zhí)行。

4. 靜態(tài)內部類（Static Inner Classes）

靜態(tài)內部類是定義在另一個類內部并被聲明為 static 的類。它與外部類無關，并且可以直接通過外部類名訪問。

public class OuterClass {
    static class StaticInnerClass {
        // 靜態(tài)內部類的定義
    }
    // ...
}

在上面的例子中，StaticInnerClass 是一個靜態(tài)內部類，可以使用 OuterClass.StaticInnerClass 來訪問它。

總結

• static 關鍵字用于創(chuàng)建靜態(tài)成員，這些成員屬于類而不是實例化對象。
• 靜態(tài)變量被整個類的所有實例共享，可以通過類名直接訪問。
• 靜態(tài)方法不依賴于實例化對象，可以通過類名直接調用。
• 靜態(tài)代碼塊在類加載時執(zhí)行一次，并用于初始化靜態(tài)變量和執(zhí)行其他與類有關的靜態(tài)操作。
• 靜態(tài)內部類是定義在另一個類內部的類，并且可以直接通過外部類名訪問。

Java靜態(tài)變量是隨著類的加載而加載的，它們在類被加載進內存時就會被初始化，并且在整個程序運行過程中只會有一份拷貝。相比之下，對象變量則需要在創(chuàng)建對象時才會被分配內存空間并進行初始化。因此，靜態(tài)變量優(yōu)先于對象的出現(xiàn)，可以通過類名直接訪問，無需實例化對象。

玖._. Java包（package）

在Java中，包（Package）是一種用于組織和管理類和接口的機制。它提供了一種命名空間的概念，可以將相關的類和接口組織在一起，以便更好地組織和管理代碼。

包的定義：
包是一個由點分隔的標識符序列，用于唯一標識一個類或接口所屬的組織或模塊。包名通常使用小寫字母，按照約定采用逆域名命名規(guī)則，例如：com.example.mypackage。

包的格式：
在源代碼文件的開頭，使用 package 聲明來指定該文件中的類或接口所屬的包。聲明應該位于所有 import 語句之前，并且只能有一個包聲明。例如：

package com.example.mypackage;

書寫注意事項：

• 包名應具有描述性，能夠清晰表達其所包含的類或模塊的功能。
• 包名中使用小寫字母，避免使用特殊字符或空格。
• 包名要遵循逆域名命名規(guī)則，確保全局唯一性，避免與其他包產生沖突。
• 包名中可以使用數(shù)字和下劃線，但不推薦作為包名的開頭字符。
• 包名中的每個部分都應該是有效的標識符，不能使用Java的關鍵字作為包名。

簡寫形式：
Java中的包還支持使用通配符簡寫形式，用于導入整個包或包中的所有類。有兩種常見的簡寫形式：

• 導入整個包：import com.example.mypackage.*;，表示導入 com.example.mypackage 包中的所有類。
• 導入特定類：import com.example.mypackage.MyClass;，表示只導入 com.example.mypackage 包中的 MyClass 類。

版本號：
包本身并不直接與版本號相關聯(lián)，版本號更多地與類庫（庫文件）或JAR文件相關。在Maven等構建工具中，可以在依賴項聲明中指定特定版本的庫。例如，com.example:mylibrary:1.0.0 表示引用了名為 mylibrary 的庫的版本 1.0.0。

總之，包在Java中是一種組織和管理類和接口的機制，有固定的命名規(guī)則和書寫格式。通過適當命名和組織包，可以提高代碼的可讀性、可維護性和模塊化程度。

包的使用范圍，一個文件內能導入幾個包：

包的使用范圍是限定在一個項目或模塊內部，用于組織和管理代碼。它幫助解決了命名沖突問題，并提供了更好的代碼可讀性和可維護性。

在一個Java源代碼文件中，可以導入多個包。但是，只能有一個package聲明用于指定該文件中的類或接口所屬的包。這個聲明應該放在文件頂部，位于所有import語句之前。

例如：

package com.example.mypackage;

import java.util.ArrayList;
import java.util.List;

上面的示例中，文件中的類或接口將歸屬于com.example.mypackage包。同時，通過import語句導入了java.util.ArrayList和java.util.List兩個包，以便在代碼中直接使用這些類而無需完整的類名。

在一個Java源代碼文件中，可以根據(jù)需要導入多個包。每個import語句都可以單獨指定一個包，也可以使用通配符（*）導入整個包或包中的所有類。

例如：

import java.util.*; // 導入java.util包下的所有類
import java.io.File; // 導入java.io包下的File類
import com.example.mypackage.MyClass; // 導入com.example.mypackage包下的MyClass類

需要注意的是，盡管可以導入多個包，但最好只導入實際需要使用的類，避免導入過多無用的類，以提高代碼的可讀性和維護性。重復導入同一個包是合法的，但沒有額外的好處，因為只有一個package聲明指定了文件中類所屬的包。

介紹

Java 允許使用包(package) 將類組織在一個集合中。借助包可以方便地組織你的代碼并將你自己的代碼與其他人提供的代碼庫分開。

包名：

使用包的主要原因是確保類名的唯一性。假如兩個程序員不約而同地提供了 Employee只要他們將自己的類放置在不同的包中，就不會產生沖突。
事實上，為了保證包名的絕對一性，可以使用一個因特網(wǎng)域名(這顯然是唯一的)以逆序的形式作為包名，然后對于不的項目使用不同的子包。
例如，考慮域名 horstmann.c。如果逆序來寫，就得到了包名cohorstmann。然后可以追加一個項目名，如com.horstmann.corejava。如果再把 Eployee 類放在這包里，那么這個類的“完全限定”名就是 com.horstmann.corejava,Employee。
注釋:從編譯器的角度來看，嵌套的包之間沒有任何關系。例如，java.util 包與jutil.jar包毫無關系。每一個包都是獨立的類集合。

要使用庫中的類或包，您需要使用關鍵字：import

Scanner類：

Scanner類是Java中的一個工具類，用于從用戶輸入或文件中讀取數(shù)據(jù)。它提供了一種簡單的方式來解析基本類型和字符串。

要使用Scanner類，首先需要創(chuàng)建一個Scanner對象，并將輸入源（如System.in或文件）作為參數(shù)傳遞給構造函數(shù)。然后，可以使用Scanner對象的方法來讀取輸入。

以下是Scanner類的一些常用方法：

next(): 讀取并返回輸入中的下一個單詞（以空格分隔）。
nextInt(): 讀取并返回輸入中的下一個整數(shù)。
nextDouble(): 讀取并返回輸入中的下一個雙精度浮點數(shù)。
nextLine(): 讀取并返回輸入中的下一行。

next() 與 nextLine() 區(qū)別

next():

1、一定要讀取到有效字符后才可以結束輸入。
2、對輸入有效字符之前遇到的空白，next() 方法會自動將其去掉。
3、只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結束符。
next() 不能得到帶有空格的字符串。

== nextLine()：==

1、以Enter為結束符,也就是說 nextLine()方法返回的是輸入回車之前的所有字符。
2、可以獲得空白。

下面是一個使用Scanner類的示例：

import java.util.Scanner;

public class MyClass {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("請輸入一個整數(shù): ");
        int num = scanner.nextInt();
        System.out.println("您輸入的整數(shù)是: " + num);

        System.out.print("請輸入一個字符串: ");
        String str = scanner.next();
        System.out.println("您輸入的字符串是: " + str);

        scanner.close();
    }
}

在上面的示例中，首先創(chuàng)建了一個Scanner對象，并將System.in作為輸入源。然后，我們使用nextInt()方法讀取用戶輸入的整數(shù)，并使用next()方法讀取用戶輸入的字符串。最后，我們關閉了Scanner對象。

請注意，使用Scanner類時需要小心處理輸入錯誤的情況，例如輸入的數(shù)據(jù)類型與預期不符。可以使用異常處理機制來處理這些情況，以確保程序的穩(wěn)定性和可靠性。

拾._.對象數(shù)組：

對象數(shù)組是一種數(shù)據(jù)結構，它可以存儲多個對象。在Java中，可以使用對象數(shù)組來存儲同一類的多個對象。每個數(shù)組元素都可以是該類的一個實例。

 public static void main(String[] args) {
        BOOK[] book = new BOOK[3];
        for (int i = 0; i < book.length; i++) {
            book[i] = new BOOK();
        }
        for (BOOK b : book) {
            b.showDisplayBook();
        }
    }

在訪問數(shù)組中的對象時，需要進行類型轉換。由于Object是所有類的基類，因此在存儲和訪問對象時，需要將其轉換為實際的類型。文章來源地址http://www.zghlxwxcb.cn/news/detail-575975.html

// 聲明一個對象數(shù)組
Object[] myArray = new Object[5];

// 在數(shù)組中存儲不同類型的對象
myArray[0] = "Hello";
myArray[1] = 42;
myArray[2] = new ArrayList<>();
myArray[3] = new Date();
myArray[4] = new MyClass();

// 訪問數(shù)組中的對象
String str = (String) myArray[0];
int num = (int) myArray[1];
List<Object> list = (List<Object>) myArray[2];
Date date = (Date) myArray[3];
MyClass obj = (MyClass) myArray[4];

到了這里，關于我在VScode學Java類與對象（Java顯式參數(shù)和隱式參數(shù)、靜態(tài)方法+main方法、Java訪問修飾符、static關鍵字、Java的包、對象數(shù)組）第三輯的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！