Java 方法

Java方法是一组被分组在一起以执行操作的语句。当你调用System.out. println() 方法时，系统实际上会执行多个语句以在控制台上显示一条消息。

现在您将学习如何创建自己的带或不带返回值的方法，如何调用带或不带参数的方法，以及如何在程序设计中应用方法抽象。

创建方法

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

语法

public static int methodName(int a, int b) {
   // body
}

这里,

• public static - 修饰符

• int - 返回类型

• methodName - 方法名

• a, b - 形式参数

• int a, int b - 参数列表

方法定义由方法头和方法体组成。相同的结构如下所示 –

语法

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

上述语法包括以下内容：

• modifier — 定义方法的访问类型，可选择使用。

• returnType — 方法可能返回一个值。

• nameOfMethod — 这是方法的名称。方法签名由方法名称和参数列表组成。

• Parameter List — 参数的列表，包括方法的类型、顺序和数量。这些是可选的，方法可以不含任何参数。

• method body — 方法体定义了方法执行的具体语句。

示例

以下是上述定义的方法min()的源代码。该方法接受两个参数num1和num2，并返回两者中的最大值。

/** 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; 
}

方法调用

为了使用一个方法，需要调用它。一个方法可以通过两种方式进行调用，即返回一个值或者不返回任何值（没有返回值）。

方法调用的过程很简单。当程序调用一个方法时，程序控制权会转移到被调用的方法中。被调用的方法在满足以下两个条件时将控制权返回给调用者：

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

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

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

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

int result = sum(6, 9);

以下是一个示例，演示如何定义一个方法以及如何调用它:

示例

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

void关键字

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

示例

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

按值传递参数

在调用过程中，需要传递参数。这些参数应该按照方法规范中对应的参数顺序传递。参数可以按值传递或按引用传递。

按值传递参数意味着调用一个带有参数的方法。通过此方式，参数的值被传递给参数。

示例

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

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

方法重载

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

让我们考虑之前讨论的找到整数类型最小数字的示例。假设我们想找到双精度类型的最小数字。那么就会引入重载的概念，创建两个或更多同名但参数不同的方法。

以下的示例解释了这个概念：

示例

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

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

使用命令行参数

有时你希望在运行程序时传递一些信息。这可以通过向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

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

示例

这是一个使用 this 关键字访问类成员的示例。将以下程序复制并粘贴到一个名为 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 num to the instance variable num
      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

可变参数（var-args）

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() 方法确保该对象拥有的打开文件被关闭。

要向类添加 finalizer，只需定义 finalize() 方法。Java运行时在准备回收该类的对象时调用该方法。

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

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

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

在这里，关键字protected是一个限定符，防止代码定义在类外部的地方访问finalize()。

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