Java 简明教程

Java - Methods

Java Methods

Java method 是一个语句集合，将其组合在一起来执行一个操作。例如，当您调用 System.out.println() 方法时，系统实际上执行多个语句来在控制台上显示一条消息。

在本教程中，我们将学习如何创建有或没有返回值自己的方法，调用有或没有参数的方法，以及在程序设计中应用方法抽象。

Creating a Java Method

若要创建 Java 方法，应该有 access modifier，后面是返回类型、方法的名称和参数列表。

Syntax to Create a Java Method

考虑以下示例来解释一个方法的语法 −

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

上面显示的语法包括：

  1. modifier − 它定义方法的访问类型，是否使用它是可选的。

  2. returnType − 方法可以返回值。

  3. nameOfMethod − 这是方法名。方法签名由方法名和参数列表组成。

  4. Parameter List − 参数列表，它是方法的类型、顺序和参数数。它们是可选的，方法可以不带任何参数。

  5. method body− 方法主体通过各种命令定义方法的作用。

Example to Create a Java Method

以下是名为 minFunction() 的上述定义方法的源代码。此方法采用两个参数 n1 和 n2，并返回两者的最小值 −

/** the snippet returns the minimum between two numbers */

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

   return min;
}

Calling a Java Method

要使用一个方法，应该调用它。有两种方式可以调用一个方法：方法返回一个值或不返回任何值（没有返回值）。

方法调用的过程很简单。当一个程序调用一个方法时，程序控制将转移到被调用的方法。这个被调用的方法然后在两个条件下将控制返回给调用者，当 −

  1. 执行了 return 语句。

  2. 它到达了方法结束大括号。

返回 void 的方法被视为调用语句。我们考虑一个示例−

System.out.println("This is tutorialspoint.com!");

返回值的方法可以由以下示例理解−

int result = sum(6, 9);

Example: Defining and Calling a Java Method

以下是如何定义一个方法以及如何调用它的示例−

public class ExampleMinNumber {

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

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min;
   }
}
Minimum value = 6

The void Keyword with Java Methods

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

Example: Use of void keyword with Methods

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("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}
Rank:A1

Passing Parameters by Value in Java Methods

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

按值传递参数表示用一个参数调用一个方法。通过这种方式，参数值传递给参数。

Example: Passing Parameters by Value

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

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);

      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}
Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Java Methods Overloading

当一个类有两个或更多具有相同名称但不同参数的方法时，它被称为方法重载。它不同于重写。在重写中，一个方法具有相同的方法名、类型、参数数量等。

我们考虑前面讨论的用于查找最小整数类型数字的示例。如果我们希望找到最小双精度类型数字。然后将引入重载的概念来创建两个或更多具有相同名称但不同参数的方法。

以下示例对此进行了说明−

Example: Methods Overloading in Java

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

      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

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

      return min;
   }

   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min;
   }
}
Minimum Value = 6
Minimum Value = 7.3

方法重载使程序可读。此处，两个方法具有相同的名称，但具有不同的参数。整型和双精度类型中的最小数字是结果。

Using Command-Line Arguments

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

当执行程序时，紧跟程序名称后的信息就是命令行参数。在 Java 程序中访问命令行参数非常容易。它们被存储为传递给 main( ) 的 String 数组中的字符串。

Example

以下程序显示了它被调用的所有命令行参数 -

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

The this Keyword inside Java Methods

this 是 Java 中的关键字，用作对当前类对象（带有一个实例方法或 constructor）的引用。使用此关键字，您可以引用类的成员（例如构造函数、 variables 和 methods）。

Note− 关键字 this 只用在实例方法或构造函数内

this

一般来说，关键字 this 用于 −

  1. 在构造函数或方法中，区分具有相同名称的实例变量和局部变量。

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

  1. 在类中，从另一个类中调用一种类型的构造函数（带参数构造函数或默认构造函数）。它称为显式构造函数调用。

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

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

Example: Use of this keyword in Java Methods

以下是一个使用此关键字访问类成员的示例。将以下程序复制并粘贴到名为 This_Example.java 的文件中。

public class This_Example {
   // Instance variable num
   int num = 10;

   This_Example() {
      System.out.println("This is an example program on keyword this");
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();

      // Assigning the local variable <i>num</i> to the instance variable <i>num</i>
      this.num = num;
   }

   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }

   public void print() {
      // Local variable num
      int num = 20;

      // Printing the local variable
      System.out.println("value of local variable num is : "+num);

      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);

      // Invoking the greet method of a class
      this.greet();
   }

   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();

      // Invoking the print method
      obj1.print();

      // Passing a new value to the num variable through parametrized constructor
      This_Example obj2 = new This_Example(30);

      // Invoking the print method again
      obj2.print();
   }
}
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Java Methods Variables Arguments (var-args)

JDK 1.5 允许您向方法传递可变数量的同类型参数。方法中的参数声明如下 -

typeName... parameterName

在方法声明中，您指定类型，后跟省略号 (…​)。一个方法中只能指定一个可变长度参数，该参数必须是最后一个参数。任何常规参数都必须在它之前。

Example: Use of Variables Arguments (var-args)

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

The finalize( ) Method

可以定义一种方法，在垃圾收集器对某个对象进行最终销毁之前，将会调用该方法。此方法称为 finalize( )，可用于确保对象干净地终止。

例如，您可以使用 finalize( ) 确保由该对象拥有的打开文件已关闭。

要为类添加一个终结器，只需定义 finalize( ) 方法。每当 Java 运行时准备回收该类的对象时，就会调用该方法。

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

finalize( ) 方法具有以下常规形式 −

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

此处，关键字 protected 是一个说明符，该说明符阻止定义在其类外部的代码访问 finalize( )。

这意味着你无法知道finalize()何时或是否会被执行。例如，如果你的程序在垃圾收集发生之前结束，则finalize()将不会执行。