Java方法

Java方法是組合在一起來執行操作語句的集合。當調用System.out.println方法，例如，該係統實際上是為了在控製台上顯示的消息執行多條語句。

現在，您將學習如何創建自己的方法有或冇有返回值，調用帶或不帶參數，使用相同的名稱重載方法的方法，並運用抽象的方法在程序設計中。

創建方法:

在一般情況下，方法的語法如下:

modifier returnValueType methodName(list of parameters) {
  // Method body;
}

方法定義包括方法頭和方法體。下麵是一個方法的所有部分：

修飾符: 修飾符是可選的，告訴編譯器如何調用該方法。這定義了該方法的訪問類型。
返回類型: 方法可以返回一個值。returnValueType的值是方法返回的數據類型。有些方法冇有返回值執行所需的操作。在這種情況下，returnValueType是關鍵字void.
方法名稱: 這是方法的實際名稱。方法名和參數列表一起構成了方法簽名.
參數: 參數像一個占位符. 當調用一個方法，傳遞一個值給參數. 這個值被稱為實際參數或參數. 參數列表是指類型，順序和方法的參數的個數. 參數是可選的，也就是說，一個方法可以包含任何參數.
方法體: 方法體包含定義哪些方法語句的集合.

注: 在某些其它語言中，方法被稱為過程和函數. 非void返回值類型的方法被調用的函數; 有一個void返回值類型的方法被調用的程序.

例子：

這裡是上麵定義的方法的源代碼，調用 max(). 這個方法有兩個參數num1和num2，並返回兩者之間的最大：

/** Return the max between two numbers */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;

   return result; 
}

調用方法：

在創建一個方法，是做什麼的定義。若要使用方法，必須調用它。有兩種方法來調用一個方法，該選擇是基於該方法是否返回一個值或冇有。

當程序調用一個方法時，程序控製權轉移到被調用的方法。一個名為方法將控製返回給調用者時，其執行return語句或當達到其方法結束的右大括號。

如果該方法返回一個值，調用該方法通常被視為一個值。例如：

int larger = max(30, 40);

如果該方法返回void，則調用該方法必須是一個語句。例如，println方法返回void。下麵的調用是一個語句：

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

例子：

以下是該示例演示如何定義一個方法，以及如何調用它：

public class TestMax {
   /** Main method */
   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);
   }

   /** Return the max between two numbers */
   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方法的頭始終是相同的，像在這個例子中，用修飾符public和static，返回值類型為void，方法名main和String[]類型的參數。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');
      }
   }
}

這將產生以下結果:

在這裡，printGrade方法是一個void方法。它不返回任何值。調用一個void方法必須是一個語句。因此，它被調用在第3行中的main方法的聲明。此語句像分號結尾的Java語句。

通過值傳遞參數：

當調用一個方法時，需要提供的參數，它必須以相同的順序被指定為他們在法規範的相應參數。這就是所謂的參數順序關聯。

例如，下麵的方法打印n次消息：

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

在這裡，可以使用nPrintln("Hello", 3) 打印“Hello”三次。nPrintln("Hello", 3)語句通過實際的字符串參數，“Hello”這個參數來消息，打印“Hello”三次。不過，聲明nPrintln(3, "Hello") 是錯誤的。

當使用一個參數調用一個方法時，參數的值傳遞給參數。這被稱作通過按值傳遞。如果參數是一個變量，而不是一個文本值，該變量的值傳遞給參數。可變不受影響，而不管是由於該參數的方法內的變化。

為簡單起見，Java程序員常說傳遞一個參數x到參數y，這實際上意味著通過x的值設置為y。

例子：

下麵是一個程序，演示了按值傳遞的效果。該程序創建用於交換兩個變量的方法。Swap方法是通過傳遞兩個參數調用。該方法被調用後不會改變的參數值。

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);

      // Invoke the swap method
      swap(num1, num2);
      System.out.println("After swap method, num1 is " +
                         num1 + " and num2 is " + num2);
   }
   /** Method to swap two variables */
   public static void swap(int n1, int n2) {
      System.out.println("	Inside the swap method");
      System.out.println("		Before swapping n1 is " + n1
                           + " n2 is " + n2);
      // Swap n1 with n2
      int temp = n1;
      n1 = n2;
      n2 = temp;

      System.out.println("		After 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

重載方法：

前麵使用 max方法僅適用於int數據類型。但是，如果需要找到其中兩個浮點數的具有最大的值呢，怎麼辦？解決的辦法是用相同名稱但由不同的參數來建立另一種方法，如下麵的代碼：

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

如果調用max為int參數，即整型參數將被調用的max方法，如果調用max傳遞double類型參數，即預計double參數將被調用max()方法。這被稱為方法的重載，也就是說，兩種方法具有相同名稱但不同的參數列表在一個類中。

Java編譯器決定哪些方法是根據方法的簽名中使用。重載方法可以使程序更清晰，更具可讀性。執行密切相關的工作方法應給予相同的名稱.

重載的方法必須有不同的參數列表。不能重載根據不同的修飾方法或返回類型. 有時是由於類似的方法簽名的方法的調用兩個或多個可能的匹配，所以編譯器無法確定最精確的匹配。這被稱為不明確的調用.

變量的作用域:

一個變量的範圍是其中變量可以被引用的程序的一部分。在一個方法中定義的變量稱為局部變量。

局部變量的範圍始於它的聲明，並繼續到包含該變量的塊的結束。局部變量必須先聲明它才能使用。

一個參數實際上是一個局部變量。方法參數的範圍包括整個方法。

在一個初始動作部分的for循環頭部聲明的變量具有其在整個循環範圍。但裡麵聲明的for循環體內的變量具有其範圍僅限於從聲明的循環體，其中包含如下所示的變量塊的結尾：

可以在一個方法不同的非嵌套塊相同的名字多次聲明一個局部變量，但不能在嵌套塊中聲明一個局部變量兩次。

使用命令行參數：

當運行它來傳遞信息到一個程序。這是通過命令行參數main（）來完成。

命令行參數是直接跟隨在命令行程序的名稱在執行時的信息。要訪問一個Java程序中的命令行參數是很容易的。它們被存儲為字符串傳遞給main() 的String數組中。

例子：

下麵的程序顯示所有的命令行參數，它被調用：

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會自動提供一個默認的構造函數來初始化所有成員變量為零。然而，一旦定義自己的構造函數，默認的構造函數不再使用。

例子：

下麵是一個使用一個構造一個簡單的例子：

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   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);
   }
}

大多數情況下，需要接受一個或多個參數的構造函數。參數被添加到一個構造函數，因為它們被添加到一個方法以同樣的方式，構造函數的名稱後到剛剛聲明它們的括號內。

例子：

下麵是一個使用一個構造一個簡單的例子：

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   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

可變參數（VAR-參數）：

JDK 1.5中，可以將可變數量的相同類型的參數傳遞到一個方法。該方法中的參數聲明如下：

typeName... parameterName

在方法聲明中，指定後跟省略號（...）隻有一個可變長度參數可以在一個方法中指定的類型，這個參數必須是最後一個參數。任何常規參數必須在它前麵。

例子：

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable 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( ) 方法:

這是可能的定義，將剛剛被垃圾收集器的對象的最終毀滅之前被調用的方法。調用方法finalize()，並且它可以被用來確保一個對象終止清理乾淨。

例如，可能使用的finalize()，以確保該對象擁有一個打開的文件關閉。

為了要終結器添加到類，隻需要定義finalize()方法。 Java運行時調用該方法時，它是關於回收該類的一個對象。

finalize方法裡麵，將指定一個對象被銷毀之前，必須執行這些操作。

finalize()方法的通用格式如下：

protected void finalize( )
{
   // finalization code here
}

在這裡，關鍵字protected是一個規範，防止訪問在finalize（）其類外定義代碼。

可以不知道什麼時候或者即使finalize()執行。例如，如果垃圾收集發生在程序結束前，finalize()將不會執行。