Course 模块 1 - Lecture: Java 中的方法参数

1.传递参数

现在乐趣开始了。您可能已经从类似的方法中了解到System.out.println()我们可以将参数传递给方法。一旦我们进入方法内部，我们就将它们称为参数。事实上，参数极大地增强了我们从创建和使用方法中获得的好处。

我们如何声明带参数的方法？其实很简单：

public static void name(parameters)
{
  method body
}

其中name 是方法的唯一名称，method body 代表组成该方法的命令。Andparameters 是方法参数的占位符，以逗号分隔。让我们更详细地描述这个模板：

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

例子：

代码	解释
`public static void print(String str) { }`	该`print`方法使用参数声明： `String str`
`public static void print(String str, int count) { }`	该`print`方法使用两个参数声明： `String str` `int count`
`public static void write(int x, int y) { }`	该`write`方法使用两个参数声明： `int x` `int y`

如果我们不想让方法有参数，那么我们就把括号留空。

参数是方法中的特殊变量。在它们的帮助下，您可以在调用方法时将各种值传递给该方法。

例如，让我们编写一个方法，将一串文本显示给定的次数。

您已经知道如何编写代码在屏幕上多次显示一个字符串。但是你应该打印哪个字符串呢？多少次？这就是我们需要参数的原因。

执行此操作的代码如下所示：

代码解释

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

我们printLines使用以下参数声明该方法：
String text,int count
该方法显示 Stringtext count次

我们printLines使用各种参数调用该方法

每次调用方法时，都会为其参数分配传递的值，然后我们才开始执行方法内部的命令。

2. 争论

我想提请您多注意调用带参数的方法。

传递给方法的值在传递给方法时通常称为参数。

让我们看另一个例子：

代码	解释
`class Solution { public static void printLines(String text, int count) { for (int i = 0; i < count; i++) System.out.println(text); } public static void main(String[] args) { printLines("Hi", 10); printLines("Bye", 20); } }`	我们`printLines`使用以下参数声明该方法： `String text`,`int count` 该方法显示 String`text` `count`次我们`printLines`使用以下参数调用该方法： `text = "Hi"; count = 10;` `text = "Bye"; count = 20;`

当printLines 第一次调用该方法时，它的参数被分配了以下值：
String text = "Hi", int count = 10。

printLines第二次调用该方法时，其参数被赋予了不同的值：
String text = "Bye", int count = 20.

参数不多于也不少于调用方法时被赋予特定值的变量。值"Hi"、"Bye"、10和20本身称为参数。”

3.调用方法时变量名冲突

变量可以用作方法参数。这是简单易懂的，但它可能会产生一些困难。让我们回到同一个例子，但这次我们将把参数移到单独的变量中：

代码解释

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

我们printLines使用以下参数声明该方法：
String text,int count
该方法显示 Stringtext count次

我们printLines使用以下参数调用该方法：
text = str;
count = n;

到目前为止，还不错：我们有一个str变量。text它的值在调用方法时分配给参数。我们有一个n变量。count它的值在调用方法时分配给参数。”至此，一切都清楚了。

现在让我们重命名方法中的变量main：

代码解释

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

我们printLines使用以下参数声明该方法：
String text,int count
该方法显示 Stringtext count次

我们printLines使用以下参数调用该方法：
text = text;
count = count;

注意两点

第一：我们在不同的方法中有同名的变量。这些是不同的变量（我们故意用不同的颜色来描绘它们）。一切都与前面的示例相同，其中方法中的变量main被命名为str和n。

第二：调用该方法时不会发生任何神奇的事情。参数只是简单地分配参数值。不管它们是数字、字符串、变量还是表达式。

在我们重命名 main 方法中的变量之后，什么都没有改变。它们以前是不同方法中的不同变量，所以它们仍然存在。text 在和变量之间没有神奇的联系text 。

4.传递对方法的引用

我希望你已经理解了上一课的所有内容，因为现在我们将重新讨论将参数传递给方法，只是我们会深入探讨。

正如您已经知道的，一些 Java 变量存储的不是值本身，而是一个引用，即值所在的内存块的地址。这就是字符串变量和数组变量的工作方式。

当您将另一个数组变量分配给一个数组变量时，会发生什么？这是正确的。这两个变量开始引用内存中的相同空间：

如果这些变量之一是方法参数，会发生什么？

代码解释

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }

   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

该printArraySum方法计算传入数组中数字的总和并将其显示在屏幕上

完全一样的事情发生了：data 参数将包含对与变量相同的内存区域的引用months。调用该方法时，会发生一个简单的赋值：。data = months

并且由于两个变量都引用存储整数的同一内存区域，因此该printArraySum 方法不仅可以从数组中读取值，还可以更改它们！

例如，我们可以编写自己的方法，用相同的值填充一个二维数组。这就是它的样子：

代码解释

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

该fill 方法遍历传递的二维数组中的每个单元格并分配value给它们。

我们创建一个二维数组。
我们用数字填充整个数组8。

5.同名方法

现在让我们再次回到方法名称。

Java 标准要求同一类中的所有方法都具有唯一的名称。换句话说，不可能在同一个类中声明两个同名方法。

当比较方法的相同性时，不仅要考虑名称，还要考虑参数的类型！请注意，不考虑参数的名称。例子：

代码解释

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

这三种方法是不同的方法。它们可以在同一个类中声明。

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

这五种方法中的每一种都被认为是不同的。它们可以在同一个类中声明。

void sum(int x, int y) {
}
void sum(int data, int value) {
}

这两个方法被认为是相同的，这意味着它们不能在同一个类中声明。

为什么有些方法被认为是相同的，而另一些则不同？为什么在确定方法的唯一性时不考虑参数名称？

为什么唯一性是必要的？关键是当编译器编译一个程序时，它必须确切地知道你打算在任何给定的地方调用哪个方法。

例如，如果你写，编译器很聪明，很容易断定你打算用参数调用这里的方法。System.out.println("Hi")println()String

但是，如果您编写，编译器将看到对带有参数的方法的调用。System.out.println(1.0)println()double

调用方法时，编译器确保参数的类型与参数的类型相匹配。它不注意参数的名称。在 Java 中，参数名称不帮助编译器确定调用哪个方法。这就是为什么在确定方法的唯一性时不考虑它们的原因。

方法的名称及其参数的类型称为方法签名。例如，sum(int, int)

每个类都必须具有具有唯一签名的方法，而不是具有唯一名称的方法。