Java 方法

Java 方法是一组被组合在一起执行某个操作的语句。当你调用 System.out.println() 方法时，系统实际上执行了若干条语句来显示控制台上的信息。

在这个教程中，我们将学习如何创建带有或不带返回值的方法、带或不带参数的方法调用以及在程序设计中应用方法抽象。

创建 Java 方法

创建 Java 方法时，应该有一个访问修饰符，后面跟着返回类型、方法名和参数列表。

创建 Java 方法的语法

以下是一个例子，用来解释方法的语法：

修饰符 返回类型 方法名 (参数列表) {
   // 方法体
}

上述语法包括：

修饰符 - 定义方法的访问类型，它是可选的。
返回类型 - 方法可能会返回一个值。
方法名 - 这是方法名。方法签名由方法名和参数列表组成。
参数列表 - 参数列表是方法的类型、顺序和数量。这是可选的，方法可能包含零个参数。
方法体 - 方法体定义了方法通过语句所做的事情。

创建 Java 方法的示例

以下是定义的方法 minFunction() 的源代码。该方法接受两个参数 n1 和 n2 并返回两者之间的最小值：

/** 该代码段返回两个数字之间的最小值 */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

调用 Java 方法

为了使用一个方法，需要调用它。有两种方式来调用一个方法，即方法返回一个值或不返回任何值（没有返回值）。

调用方法的过程很简单。当程序调用一个方法时，程序控制权被转移到被调用的方法。被调用的方法会在以下两种情况下之一返回控制权给调用者：

执行了 return 语句。
到达方法结尾的大括号。

返回 void 的方法被认为是对一条语句的调用。让我们来看一个例子：

System.out.println("这是 tutorialspoint.com!");

返回值的方法可以通过以下示例理解：

int result = sum(6, 9);

示例：定义和调用 Java 方法

以下是定义一个方法并调用它的示例：

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("最小值 = " + c);
   }

   /** 返回两个数字中的最小值 */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

输出

最小值 = 6

Java 方法中的 `void` 关键字

void 关键字允许我们创建不返回任何值的方法。以下面的例子为例，我们考虑了一个 void 方法 methodRankPoints。这是一个 void 方法，不返回任何值。调用 void 方法必须是一条语句，即 methodRankPoints(255.7);。这是一个以分号结尾的 Java 语句，如下面的例子所示。

示例：`void` 关键字与方法一起使用

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("等级:A1");
      } else if (points >= 122.4) {
         System.out.println("等级:A2");
      } else {
         System.out.println("等级:A3");
      }
   }
}

输出

等级:A1

Java 方法中按值传递参数

在调用过程中，需要传递参数。这些参数应按照与方法规范中各自的参数相同的顺序传递。参数可以通过值传递或通过引用传递。

按值传递参数意味着通过参数调用一个方法。通过这种方式，参数值被传给了实参。

示例：按值传递参数

下面的程序展示了按值传递参数的一个例子。即使在方法调用之后，参数的值仍然保持不变。

public class SwappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("交换前，a = " + a + " 和 b = " + b);

      // 调用交换方法
      swapFunction(a, b);
      System.out.println("\n**现在，在交换前后值将相同**:");
      System.out.println("交换后，a = " + a + " 和 b 是 " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("交换前(内部)，a = " + a + " b = " + b);
      
      // 交换 a 和 b
      int c = a;
      a = b;
      b = c;
      System.out.println("交换后(内部)，a = " + a + " b = " + b);
   }
}

输出

交换前，a = 30 和 b = 45
交换前(内部)，a = 30 b = 45
交换后(内部)，a = 45 b = 30

**现在，在交换前后值将相同**:
交换后，a = 30 和 b 是 45

Java 方法重载

当一个类中有两个或多个同名但参数不同的方法时，这就叫做方法重载。它不同于覆盖（overriding）。覆盖是指方法具有相同的方法名、类型、参数数量等。

让我们考虑前面讨论过的查找整型最小数的例子。假设我们想要找出双精度类型（double）的最小数。那么，将引入重载的概念来创建具有相同名称但不同参数的两个或多个方法。

下面的例子说明了这一点：

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // 相同的方法名，不同的参数
      double result2 = minFunction(c, d);
      System.out.println("最小值 = " + result1);
      System.out.println("最小值 = " + result2);
   }

   // 对于整型
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // 对于双精度型
   public static double minFunction(double n1, double n2) {
      double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

输出

最小值 = 6
最小值 = 7.3

重载方法使得程序更易读。这里，给出了相同名称但不同参数的两个方法。整型和双精度型的最小数就是结果。

使用命令行参数

有时，你希望在运行程序时传递一些信息。这可以通过将命令行参数传递给 main() 来实现。

命令行参数是在执行程序时直接跟随程序名称的信息。在 Java 程序中访问命令行参数非常简单。它们存储在传递给 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 这是 一个 命令 行 200 -100

输出

args[0]: 这是
args[1]: 一个
args[2]: 命令
args[3]: 行
args[4]: 200
args[5]: -100

Java 方法中的 `this` 关键字

this 是 Java 中的一个关键字，在实例方法或构造函数中作为对当前类对象的引用。使用 this 可以引用类的成员，如构造函数、变量和方法。

注意：关键字 this 只能在实例方法或构造函数中使用。

通常，关键字 this 用于：

在构造函数或方法内区分同名的实例变量和局部变量。

class Student {
   int age;   
   Student(int age) {
      this.age = age; 
   }
}

在类中从一种构造函数（带参数构造函数或默认构造函数）调用另一种构造函数。这被称为显式构造函数调用。

class Student {
   int age;
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age; 
   }
}

Java 方法中的 `this` 关键字示例

下面是使用 this 关键字来访问类成员的一个例子。你可以把这个程序复制粘贴到名为 This_Example.java 的文件中。

示例：Java 方法中 `this` 关键字的使用

public class This_Example {
   // 实例变量 num
   int num = 10;
 
   This_Example() {
      System.out.println("这是一个关于关键字 this 的示例程序"); 
   }

   This_Example(int num) {
      // 调用默认构造器
      this();
      
      // 将局部变量 num 赋值给实例变量 num
      this.num = num;    
   }
   
   public void greet() {
      System.out.println("嗨，欢迎来到 Tutorialspoint");
   }
      
   public void print() {
      // 局部变量 num
      int num = 20;
      
      // 打印局部变量
      System.out.println("局部变量 num 的值是 : " + num);
      
      // 打印实例变量
      System.out.println("实例变量 num 的值是 : " + this.num);
      
      // 调用类的 greet 方法
      this.greet();     
   }
   
   public static void main(String[] args) {
      // 实例化类
      This_Example obj1 = new This_Example();
      
      // 调用 print 方法
      obj1.print();
   
      // 通过带参数的构造器为 num 变量传递新值
      This_Example obj2 = new This_Example(30);
      
      // 再次调用 print 方法
      obj2.print(); 
   }
}

输出

这是一个关于关键字 this 的示例程序
局部变量 num 的值是 : 20
实例变量 num 的值是 : 10
嗨，欢迎来到 Tutorialspoint
这是一个关于关键字 this 的示例程序
局部变量 num 的值是 : 20
实例变量 num 的值是 : 30
嗨，欢迎来到 Tutorialspoint

Java 方法中的可变参数（Varargs）

从 JDK 1.5 开始，你可以向方法传递同一类型的可变数量的参数。方法中的参数声明如下：

typeName... parameterName

在方法声明中，你需要指定类型后跟三个点（...）。在一个方法中只能指定一个可变参数，并且这个参数必须是最后一个参数。任何常规参数都必须在其之前。

示例：使用可变参数（Varargs）

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("没有传递参数");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i < numbers.length; i++)
         if (numbers[i] > result)
            result = numbers[i];
      System.out.println("最大值是 " + result);
   }
}

输出

最大值是 56.5
最大值是 3.0

finalize() 方法

可以在对象被垃圾回收器最终销毁之前定义一个会被调用的方法。这个方法被称为 finalize()，可以用来确保对象干净地终止。

例如，你可以使用 finalize() 来确保对象拥有的一个打开的文件被关闭。

要给一个类添加终结器，只需定义 finalize() 方法即可。Java 运行时将在准备回收该类的对象时调用此方法。

在 finalize() 方法内部，你将指定在对象销毁之前必须执行的操作。

finalize() 方法的一般形式如下：

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

这里，protected 关键字是一个防止外部代码访问 finalize() 的限定词。

这意味着你不能确定 finalize() 何时或者是否会执行。例如，如果在垃圾收集发生之前你的程序已经结束，那么 finalize() 就不会被执行。