Java 方法的參數詳解：類型、規格與標準方法簽名

在 Java 中，方法（Method）是用來封裝可重複使用的程式邏輯的核心單位。

而方法的 參數（Parameters）則決定了方法在執行時能夠接收哪些輸入，從而影響方法的行為。

本篇文章將深入探討 Java 方法參數的類型、規格、標準方法簽名等相關概念，幫助新手理解並正確使用方法參數。

Java 方法的基本結構

在 Java 中，一個方法的基本語法如下：

修飾符 返回類型 方法名稱(參數列表) {
    // 方法內部的程式碼
    return 返回值;  //（如果有的話）
}

其中：

• 修飾符（如 public、private、static）用來控制方法的存取範圍。
• 返回類型 指定方法返回的資料類型，若無返回值則使用 void。
• 方法名稱 是方法的識別名稱。
• 參數列表（可選）用來接收傳入的值，可包含一個或多個參數。
• return（如果適用）用來回傳計算結果。

Java 方法的參數類型

在 Java 方法中，參數可以是基本數據類型（Primitive Types）或引用類型（Reference Types）。

基本數據類型（Primitive Types）

基本數據類型是 Java 提供的內建數據類型，包括：

範例：使用基本數據類型作為參數

public class Example {
    public void printSum(int a, int b) {
        int sum = a + b;
        System.out.println("總和：" + sum);
    }

    public static void main(String[] args) {
        Example example = new Example();
        example.printSum(5, 10); // 傳入兩個整數
    }
}

輸出結果

總和：15

引用類型（Reference Types）

引用類型包括：

1. 字串（String）
2. 陣列（Array）
3. 類別（Class）
4. 介面（Interface）
5. 集合類型（List、Map、Set 等）

字串 (String)

String 是 Java 的引用類型，代表不可變的字串序列。

public void greet(String name) {
    System.out.println("Hello, " + name + "!");
}

呼叫：

greet("Alice");

輸出：

Hello, Alice!

(2) 陣列 (Array)

陣列可以作為參數，允許方法接收多個值。

public void printNumbers(int[] numbers) {
    for (int num : numbers) {
        System.out.print(num + " ");
    }
}

呼叫：

printNumbers(new int[]{1, 2, 3, 4});

輸出：

1 2 3 4

物件 (Class)

方法可以接受自定義類別作為參數，例如：

class Person {
    String name;
    
    Person(String name) {
        this.name = name;
    }
}

public void printPersonInfo(Person p) {
    System.out.println("名字：" + p.name);
}

呼叫：

Person p = new Person("Tom");
printPersonInfo(p);

輸出：

名字：Tom

方法參數的規格與規則

方法參數的數量

方法的參數列表可以：

沒有參數

public void sayHello() {
    System.out.println("Hello!");
}

一個參數

public void printAge(int age) {
    System.out.println("年齡：" + age);
}

多個參數

public void add(int a, int b, int c) {
    System.out.println("總和：" + (a + b + c));
}

public void add(int a, int b, int c) { System.out.println("總和：" + (a + b + c)); }

方法參數的順序

參數的順序影響方法的使用方式，例如：

public void printInfo(String name, int age) {
    System.out.println("姓名：" + name + "，年齡：" + age);
}

呼叫：

printInfo("Alice", 25);  // ✅ 正確
printInfo(25, "Alice");  // ❌ 錯誤，參數順序不對

Java 的標準方法簽名

在 Java 中，每個方法都有一個唯一的識別方式，這稱為方法簽名（Method Signature）。

方法簽名用來區分不同的方法，並且在方法重載（Method Overloading）時，Java 會根據方法簽名來決定要執行哪一個方法。

1. 方法簽名的組成

Java 方法的標準簽名由「方法名稱 + 參數類型」組成，不包括返回類型與存取修飾符（如 public、private）。

方法簽名的範例

public void printMessage(String msg) { }  
// 方法簽名：printMessage(String)

public int sum(int a, int b) { return a + b; }  
// 方法簽名：sum(int, int)

即使這兩個方法的返回類型不同，它們的簽名仍然是不同的，因為參數類型不同。

2. 方法簽名不包含返回類型

許多新手會誤以為方法的返回類型也是方法簽名的一部分，但其實 Java 並不將返回類型視為方法簽名的一部分。

錯誤範例：方法簽名相同但返回類型不同

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

public double add(int a, int b) {  
    return a + b; 
}

這段程式碼會導致編譯錯誤，因為：

• 這兩個方法的名稱都是 add。
• 參數列表相同（int, int）。
• 唯一的不同是返回類型，但返回類型不是方法簽名的一部分，因此 Java 無法區分這兩個方法。

正確的方式：更改參數類型或數量

如果想讓 Java 能夠區分方法，必須更改參數的類型或數量，例如：

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

public double add(double a, double b) {  
    return a + b; 
}

這樣的方法是合法的，因為：

• 第一個方法的簽名是 add(int, int)。
• 第二個方法的簽名是 add(double, double)。
• 由於參數類型不同，Java 可以正確區分它們，這就是**方法重載（Method Overloading）**的概念。

3. 方法簽名的作用

• 方法識別：方法簽名是 Java 在執行時識別方法的依據。
• 方法重載（Overloading）：在同一個類別內，可以使用相同的方法名稱，但參數類型或數量必須不同，這樣 Java 就能區分它們。
• 不包括返回類型：方法簽名不包含返回類型，因此兩個方法不能僅依靠返回類型來區分，否則會造成編譯錯誤。

可變參數（Varargs，...）

當方法的參數數量不固定時，可以使用可變參數（...），例如：

public void printNumbers(int... numbers) {
    for (int num : numbers) {
        System.out.print(num + " ");
    }
}

呼叫：

printNumbers(1, 2, 3, 4, 5);

輸出：

1 2 3 4 5

案例探討：main 方法的參數 (String[] args)

我們來分析這段 Java 程式碼：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

main 方法的標準簽名

Java 規定 main 方法的標準簽名如下：

public static void main(String[] args)

它符合標準方法簽名的規則：

1. 方法名稱：main
2. 參數類型：String[]（字串陣列）
3. 參數名稱：args（名稱可變，但慣例上使用 args）

String[] args 作為方法參數

在 main 方法中，args 是一個字串陣列（String Array），用來接收命令列（Command Line）輸入的參數。例如：

(1) args 陣列的基本用法

public class Example {
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("第一個參數：" + args[0]);
        } else {
            System.out.println("沒有提供參數！");
        }
    }
}

執行方式：

java Example Hello

輸出結果：

第一個參數：Hello

(2) 處理多個參數

public class Example {
    public static void main(String[] args) {
        System.out.println("你輸入的參數：");
        for (int i = 0; i < args.length; i++) {
            System.out.println("參數 " + i + ": " + args[i]);
        }
    }
}

執行方式：

java Example Alice Bob Charlie

輸出結果：

你輸入的參數：
參數 0: Alice
參數 1: Bob
參數 2: Charlie

main 方法的 args 是否可以省略？

如果程式不需要命令列參數，仍然必須保留 String[] args，但可以不使用它：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

即使不使用 args，main 方法的參數仍然不能刪除，因為 Java 規定 main 方法的標準簽名必須是：

public static void main(String[] args)

否則 JVM（Java 虛擬機）將無法識別 main 方法並執行程式。

為什麼 Java 要規定 main 方法的標準簽名？

Java 規定 main 方法的標準簽名為：

public static void main(String[] args)

這樣的設計不是隨機的，而是有明確的技術與設計考量。以下是 Java 設計者為什麼這樣規定的幾個主要原因：

JVM 需要識別 main 方法作為程式的入口點

Java 程式的執行需要一個明確的起始點（Entry Point），Java 虛擬機（JVM）會尋找 main 方法作為程式的起點，並從這裡開始執行程式。

假如 main 方法的名稱可以自由更改，例如 startProgram()、beginExecution()，那麼 JVM 將無法知道應該執行哪個方法。

因此，Java 規定所有 Java 應用程式都必須有一個 main 方法，且方法名稱固定為 main，這樣 JVM 才能正確執行程式。

public 讓 main 方法可被 JVM 存取

main 方法必須宣告為 public，這樣 JVM 才能從外部（非類別內部）存取並執行這個方法。

如果 main 方法不是 public，例如：

class HelloWorld {
    private static void main(String[] args) {  // ❌ 錯誤，JVM 無法存取
        System.out.println("Hello, World!");
    }
}

這樣程式將無法執行，因為 JVM 嘗試執行 main 方法時，會因為 private 限制而無法存取該方法，導致執行錯誤。

所以 Java 強制要求 main 方法必須是 public，以確保 JVM 能夠順利存取並執行它。

static 讓 main 方法不需要建立物件就能執行

main 方法宣告為 static，代表它屬於類別本身，而不是某個物件的成員。這樣的設計有幾個優勢：

• 不需要先建立物件才能執行 main 方法。
  如果 main 方法不是 static，那麼 JVM 在執行 main 方法之前，必須先建立該類別的物件，這樣會讓程式的啟動變得更複雜。

例如，假設 main 方法沒有 static，則執行時需要這樣：

public class HelloWorld {
    public void main(String[] args) {  // ❌ 錯誤，無法直接執行
        System.out.println("Hello, World!");
    }
}

要執行這個 main 方法，JVM 需要這樣做：

HelloWorld obj = new HelloWorld();
obj.main(args);

這樣就變得麻煩了！

Java 的設計目標是簡單、清晰，因此 main 方法必須是 static，讓 JVM 可以直接執行它，而不需要額外建立物件。

String[] args 讓 main 方法可以接收命令列參數

在 Java 程式執行時，開發者有時會希望從命令列傳入一些參數。例如：

java MyProgram Hello 123

這些參數（Hello、123）會被存放到 args 陣列中，使 main 方法能夠存取它們：

public class MyProgram {
    public static void main(String[] args) {
        System.out.println("第一個參數：" + args[0]);
        System.out.println("第二個參數：" + args[1]);
    }
}

輸出結果：

第一個參數：Hello
第二個參數：123

這樣的設計讓 Java 應用程式可以更加靈活，因為它可以根據使用者的輸入執行不同的行為。

雖然 args 變數名稱可以更改，例如：

public static void main(String[] parameters) {
}

但 String[] 的資料類型不能更改，因為這是 Java 的標準規定，JVM 會依據這個規範來傳遞命令列參數。

main 方法的簽名提供一致性

如果 Java 允許 main 方法的定義各不相同，例如：

public static void main(int[] args) { }  // ❌ 錯誤，參數類型不同
private static void start(String[] args) { }  // ❌ 錯誤，方法名稱不同

這將導致 JVM 難以識別 main 方法，甚至可能影響不同 Java 程式之間的兼容性。

透過統一的 main 方法標準簽名：

public static void main(String[] args)

Java 保證所有 Java 應用程式都有一致的程式進入點，讓程式碼更具可讀性，也方便開發者學習與維護。

void 表示 main 方法不返回值

main 方法的返回類型必須是 void，這表示該方法不會回傳任何值給 JVM。

如果 main 方法允許返回值，例如：

public static int main(String[] args) { // ❌ 錯誤，返回類型不能是 int
    return 0;
}

這將會違反 Java 的規範，因為 JVM 並不會期待 main 方法返回一個值來決定如何執行後續操作。

規定 void 作為返回類型，使得 main 方法只用來啟動應用程式，而不會影響 JVM 的執行流程。

總結

1. Java 方法的參數可以是基本數據類型或引用類型，例如 int、String、Array 等。
2. 方法簽名由「方法名稱 + 參數類型」組成，不包含返回類型。
3. main 方法的 String[] args 用於接收命令列參數，即使不使用也不能省略。
4. 如果 main 方法沒有正確的簽名，JVM 將無法識別並執行程式。

這篇文章透過 main 方法的案例，幫助新手理解 Java 方法的參數概念。

透過熟練掌握方法的參數類型、標準簽名與 args 的使用方式，你將能夠更靈活地撰寫 Java 程式，提高程式的可讀性與擴充性！ 🚀