Java 方法

在前面幾個章節中我們常常使用到System.out.println()，那麼它是什麼呢？

println()是一個方法(Method)，而System是系統類別(Class)，out是標準輸出物件(Object)。這句話的用法是呼叫系統類別System中的標準輸出物件out中的方法println()。

那麼什麼是方法呢？

Java方法是語句的集合，它們在一起執行一個功能。

• 方法是解決一類問題的步驟的有序組合

• #方法包含於類別或物件中

• #方法在程式中被創建，在其他地方被引用

#方法的定義

#一般情況下，定義一個方法包含以下語法：

修饰符 返回值类型 方法名 (参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一個方法頭和一個方法體。以下是一個方法的所有部分：

• 修飾符：修飾符，這是可選的，告訴編譯器如何呼叫該方法。定義了該方法的存取類型。

• 傳回值類型 ：方法可能會傳回值。 returnValueType是方法傳回值的資料型別。有些方法執行所需的操作，但沒有傳回值。在這種情況下，returnValueType就是關鍵字void。

• 方法名稱：是方法的實際名稱。方法名和參數表共同構成方法簽章。

• 參數型別：參數像是佔位符。當方法被呼叫時，傳遞值給參數。這個值稱為實參或變數。參數列表是指方法的參數類型、順序和參數的個數。參數是可選的，方法可以不包含任何參數。

• 方法體：方法體包含具體的語句，定義方法的功能。

如：

public static int age(int birthday){...}

參數可以有多個：

static float interest(float principal, int year){...}

注意： 在一些其它語言中方法指涉過程和函數。一個傳回非void類型回傳值的方法稱為函數；一個傳回void類型回傳值的方法叫做過程。

實例

下面的方法包含2個參數num1和num2，它傳回這兩個參數的最大值。

/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;

   return result; 
}

方法呼叫

Java支援兩種呼叫方法的方式，根據方法是否傳回值來選擇。

當程式呼叫一個方法時，程式的控制權交給了被呼叫的方法。當被呼叫方法的回傳語句執行或到達方法體閉括號時交還控制權給程式。

當方法傳回一個值的時候，方法呼叫通常被當作一個值。例如：

int larger = max(30, 40);

如果方法回傳值是void，方法呼叫一定是一條語句。例如，方法println傳回void。下面的呼叫是個語句：

System.out.println("Welcome to Java!");

範例

下面的範例示範如何定義一個方法，以及如何呼叫它：

public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println("The maximum between " + i +
                    " and " + j + " is " + k);
   }

   /** 返回两个整数变量较大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result; 
   }
}

以上實例編譯運行結果如下：

The maximum between 5 and 2 is 5

這個程式包含main方法和max方法。 Main方法是被JVM呼叫的，除此之外，main方法和其它方法沒什麼區別。

main方法的頭部是不變的，如例子所示，帶有修飾符public和static,返回void類型值，方法名字是main,此外帶個一個String[]類型參數。 String[]表示參數是字串陣列。

void 關鍵字

本節說明如何宣告和呼叫一個void方法。

下面的範例宣告了一個名為printGrade的方法，並且呼叫它來列印給定的分數。

範例

public class TestVoidMethod {

   public static void main(String[] args) {
      printGrade(78.5);
   }

   public static void printGrade(double score) {
      if (score >= 90.0) {
         System.out.println('A');
      }
      else if (score >= 80.0) {
         System.out.println('B');
      }
      else if (score >= 70.0) {
         System.out.println('C');
      }
      else if (score >= 60.0) {
         System.out.println('D');
      }
      else {
         System.out.println('F');
      }
   }
}

以上實例編譯執行結果如下：

C

這裡printGrade方法是void類型方法，它不會回傳值。

一個void方法的呼叫一定是一個語句。 所以，它被在main方法第三行以語句形式呼叫。就像任何以分號結束的語句一樣。

透過值傳遞參數

呼叫一個方法時候需要提供參數，你必須按照參數清單指定的順序提供。

例如，下面的方法連續n次列印一個訊息：

public static void nPrintln(String message, int n) {
  for (int i = 0; i < n; i++)
    System.out.println(message);
}

範例

#下面的範例示範按值傳遞的效果。

該程式建立一個方法，該方法用於交換兩個變數。

public class TestPassByValue {

   public static void main(String[] args) {
      int num1 = 1;
      int num2 = 2;

      System.out.println("Before swap method, num1 is " +
                          num1 + " and num2 is " + num2);

      // 调用swap方法
      swap(num1, num2);
      System.out.println("After swap method, num1 is " +
                         num1 + " and num2 is " + num2);
   }
   /** 交换两个变量的方法 */
   public static void swap(int n1, int n2) {
      System.out.println("\tInside the swap method");
      System.out.println("\t\tBefore swapping n1 is " + n1
                           + " n2 is " + n2);
      // 交换 n1 与 n2的值
      int temp = n1;
      n1 = n2;
      n2 = temp;

      System.out.println("\t\tAfter swapping n1 is " + n1
                           + " n2 is " + n2);
   }
}

以上實例編譯運行結果如下：

Before swap method, num1 is 1 and num2 is 2
        Inside the swap method
                Before swapping n1 is 1 n2 is 2
                After swapping n1 is 2 n2 is 1
After swap method, num1 is 1 and num2 is 2

傳遞兩個參數呼叫swap方法。有趣的是，方法被呼叫後，實參的值並沒有改變。

方法的重載

上面所使用的max方法只適用於int型資料。但如果你想得到兩個浮點數型資料的最大值呢？

解決方法是建立另一個有相同名字但參數不同的方法，如下面程式碼所示：

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你呼叫max方法時傳遞的是int型參數，則int型參數的max方法就會被呼叫；

如果傳遞的是double型參數，則double類型的max方法體會被調用，這叫做方法重載；

就是說一個類別的兩個方法擁有相同的名字，但是有不同的參數清單。

Java編譯器根據方法簽章判斷哪個方法應該被呼叫。

方法重載可以讓程式更清晰易讀。執行密切相關任務的方法應該使用相同的名字。

重載的方法必須擁有不同的參數清單。你不能僅僅依據修飾符或返回類型的不同來重載方法。

變數作用域

變數的範圍是程式中該變數可以被引用的部分。

方法內定義的變數稱為局部變數。

局部變數的作用範圍從宣告開始，直到包含它的區塊結束。

局部變數必須宣告才可以使用。

方法的參數範圍涵蓋整個方法。參數實際上是一個局部變數。

for迴圈的初始化部分宣告的變量，其作用範圍在整個迴圈。

但循環體內宣告的變數其適用範圍是從它宣告到循環體結束。它包含如下所示的變數宣告：

你可以在一個方法裡，不同的非嵌套區塊中多次聲明一個具有相同的名稱局部變量，但你不能在巢狀區塊內兩次聲明局部變量。

命令列參數的使用

有時候你希望執行一個程式時候再傳遞給它訊息。這要靠傳遞命令列參數給main()函數實作。

命令列參數是在執行程式時候緊跟在程式名稱後面的資訊。

實例

下面的程式列印所有的命令列參數：

public class CommandLine {

   public static void main(String args[]){ 
      for(int i=0; i<args.length; i++){
         System.out.println("args[" + i + "]: " +
                                           args[i]);
      }
   }
}

#如下所示，執行這個程式：

java CommandLine this is a command line 200 -100

運行結果如下：

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

建構方法

當一個物件被建立時候，建構方法用來初始化該物件。建構方法和它所在類別的名字相同，但建構方法沒有回傳值。

通常會使用建構方法來賦予一個類別的實例變數賦初值，或執行其它必要的步驟來建立一個完整的物件。

不管你與否自訂建構方法，所有的類別都有建構方法，因為Java自動提供了一個預設建構方法，它把所有成員初始化為0。

一旦你定義了自己的建構方法，預設建構方法就會失效。

實例

下面是一個使用建構方法的範例：

// 一个简单的构造函数
class MyClass {
   int x;
   
   // 以下是构造函数
   MyClass() {
      x = 10;
   }
}

你可以像下面這樣呼叫建構方法來初始化一個物件：

public class ConsDemo {

   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x);
   }
}

大多時候需要一個有參數的建構方法。

實例

下面是一個使用建構方法的範例：

// 一个简单的构造函数
class MyClass {
   int x;
   
   // 以下是构造函数
   MyClass(int i ) {
      x = i;
   }
}

你可以像下面這樣呼叫建構方法來初始化一個物件：

public class ConsDemo {

   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

運行結果如下：

10 20

可變參數

JDK 1.5 開始，Java支援將相同類型的可變參數傳遞給一個方法。

方法的可變參數的宣告如下所示：

typeName... parameterName

在方法宣告中，在指定參數型別後加一個省略號(...) 。

一個方法中只能指定一個可變參數，它必須是方法的最後一個參數。任何普通的參數必須在它之前聲明。

實例

public class VarargsDemo {

   public static void main(String args[]) {
      // 调用可变参数的方法
	  printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
   if (numbers.length == 0) {
      System.out.println("No argument passed");
      return;
   }

   double result = numbers[0];

   for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

以上實例編譯運行結果如下：

The max value is 56.5
The max value is 3.0

finalize() 方法

Java允許定義這樣的方法，它在物件被垃圾收集器析構(回收)之前調用，這個方法叫做finalize( )，它用來清除回收物件。

例如，你可以使用finalize()來確保一個物件開啟的檔案被關閉了。

在finalize()方法裡，你必須指定在物件銷毀時候要執行的動作。

finalize()一般格式是：

protected void finalize()
{
   // 在这里终结代码
}

關鍵字protected是一個限定符，它確保finalize() 方法不會被該類別以外的程式碼呼叫。

當然，Java的記憶體回收可以由JVM來自動完成。如果你手動使用，則可以使用上面的方法。

實例

public class FinalizationDemo {  
    public static void main(String[] args) {  
        Cake c1 = new Cake(1);  
        Cake c2 = new Cake(2);  
        Cake c3 = new Cake(3);  
          
        c2 = c3 = null;  
        System.gc(); //调用Java垃圾收集器
    }  
}  
  
class Cake extends Object {  
    private int id;  
    public Cake(int id) {  
        this.id = id;  
        System.out.println("Cake Object " + id + "is created");  
    }  
      
    protected void finalize() throws java.lang.Throwable {  
        super.finalize();  
        System.out.println("Cake Object " + id + "is disposed");  
    }  
}

執行上述程式碼，輸出結果如下：

C:>java FinalizationDemo  
Cake Object 1is created  
Cake Object 2is created  
Cake Object 3is created  
Cake Object 3is disposed  
Cake Object 2is disposed