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

这将产生以下结果:

C

在这里，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()将不会执行。