Java基础入门篇——方法和重载（十四）
一、什么是方法
方法是一段封装了特定功能的代码块，可以在程序中被多次调用和重复使用。它接受输入参数（可选）并可以返回一个值（也可以是空）。在Java中，方法用于实现特定的任务或操作，并且可以被其他部分的代码调用和重用。
2.1方法的语法格式
方法由以下几个组成部分：
-
方法签名：方法的名称和参数列表的组合。方法签名用于唯一地标识一个方法。
-
参数列表：方法的输入参数，用于向方法传递数据。方法可以接受零个或多个参数。
-
返回类型：方法返回的数据类型。方法可以是void类型（不返回任何值），也可以是其他基本类型或引用类型。
-
方法体：方法的具体实现代码，它包括在方法调用时要执行的一系列语句。
[访问修饰符] 返回类型 方法名(参数列表) {
// 方法体
}
方括号表示可选部分。访问修饰符指定了其他类是否能够访问该方法。返回类型是方法返回的值的数据类型。方法名是方法的唯一标识符，用于调用该方法。参数列表包含在括号中，用于传递数据给方法。方法体是方法的具体实现。
方法示例：
public class HelloWorld {
public static void main(String[] args) {
sayHello("Alice");
}
public static void sayHello(String name) {
System.out.println("Hello, " + name + "!");
}
}
输出的结果是：
Hello, Alice!在上述示例中，我们定义了一个名为sayHello的方法。它接受一个字符串类型的参数name，并在控制台输出一条包含该参数值的问候语。在main方法中，我们通过调用sayHello方法，并传递一个参数值"Alice"来执行该方法。
二、方法的重载
方法的重载（Method Overloading）是指在同一个类中定义多个具有相同名称但参数列表不同的方法。
方法的重载允许我们给相似的操作赋予相同的方法名，这样可以提高代码的可读性和可维护性。通过方法的重载，我们可以根据传递给方法的实际参数类型和数量，来决定应该调用哪个具体的方法。
方法重载的规则如下：
- 方法必须在同一个类中进行重载。
- 方法名称必须相同。
- 参数列表必须不同，可以有不同的参数类型、参数顺序或参数数量。
- 方法的返回类型与重载无关，只依赖于方法名称和参数列表。
以下是一个示例，展示了方法重载的使用：
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
}
public class Main {
public static void main(String[] args) {
Calculator calculator = new Calculator();
System.out.println(calculator.add(2, 3)); // 调用add(int, int)方法
System.out.println(calculator.add(2.5, 3.5)); // 调用add(double, double)方法
System.out.println(calculator.add(2, 3, 4)); // 调用add(int, int, int)方法
}
}
运行的结果是：
5
6.0
9
根据调用的方法重载，运行时会根据参数的类型和数量来确定应该调用哪个具体的方法。在这个例子中，calculator.add(2, 3)将调用add(int a, int b)方法，因为两个参数都是整型。calculator.add(2.5, 3.5)将调用add(double a, double b)方法，因为两个参数都是双精度浮点型。calculator.add(2, 3, 4)将调用add(int a, int b, int c)方法，因为有三个整型参数。
三、方法递归
方法递归（Method Recursion）是指在方法的实现中调用自身的过程。
递归方法通常包含两个要素：
-
基本情况（Base Case）：定义在递归方法中的一个条件，当满足该条件时，递归将终止并返回一个特定的结果。
-
递归调用（Recursive Call）：在方法的实现中使用方法本身调用的过程。
递归方法通过将问题分解为更小的子问题，并在每个子问题上调用自身来解决问题。这种自我调用的方式使得递归方法能够处理更复杂的问题，而不需要编写多层嵌套的循环结构。
以下是一个简单的示例，展示了使用递归方法来计算阶乘：
public class Factorial {
public static int factorial(int n) {
if (n == 0) {
return 1; // 基本情况：0的阶乘为1
} else {
return n * factorial(n - 1); // 递归调用：n的阶乘为n乘以n-1的阶乘
}
}
public static void main(String[] args) {
int result = factorial(5);
System.out.println("5的阶乘为：" + result);
}
}
运行的结果是：
5的阶乘为：120我们定义了一个阶乘的递归方法factorial，它基于以下原则：
阶乘的基本情况是当输入的数字为0时，阶乘为1。
在其他情况下，递归调用factorial(n - 1)来计算n乘以(n - 1)的阶乘。
在main方法中，我们调用factorial(5)来计算5的阶乘并将结果打印出来。
3.1使用递归实现九九乘法表
以下是使用递归方法实现九九乘法表的示例代码：
public class MultiplicationTable {
public static void printMultiplicationTable(int row, int col) {
if (row > 9) {
return; // 结束递归，当行数大于9时
}
if (col > row) {
System.out.println(); // 列数大于行数时换行
printMultiplicationTable(row + 1, 1); // 递归调用下一行
return;
}
System.out.print(row + " × " + col + " = " + (row * col) + "\t"); // 打印当前行和列的乘法结果
printMultiplicationTable(row, col + 1); // 递归调用下一列
}
public static void main(String[] args) {
printMultiplicationTable(1, 1); // 从第1行第1列开始打印九九乘法表
}
}
运行的结果如下所示：
1 × 1 = 1 1 × 2 = 2 1 × 3 = 3 1 × 4 = 4 1 × 5 = 5 1 × 6 = 6 1 × 7 = 7 1 × 8 = 8 1 × 9 = 9
2 × 1 = 2 2 × 2 = 4 2 × 3 = 6 2 × 4 = 8 2 × 5 = 10 2 × 6 = 12 2 × 7 = 14 2 × 8 = 16 2 × 9 = 18
3 × 1 = 3 3 × 2 = 6 3 × 3 = 9 3 × 4 = 12 3 × 5 = 15 3 × 6 = 18 3 × 7 = 21 3 × 8 = 24 3 × 9 = 27
4 × 1 = 4 4 × 2 = 8 4 × 3 = 12 4 × 4 = 16 4 × 5 = 20 4 × 6 = 24 4 × 7 = 28 4 × 8 = 32 4 × 9 = 36
5 × 1 = 5 5 × 2 = 10 5 × 3 = 15 5 × 4 = 20 5 × 5 = 25 5 × 6 = 30 5 × 7 = 35 5 × 8 = 40 5 × 9 = 45
6 × 1 = 6 6 × 2 = 12 6 × 3 = 18 6 × 4 = 24 6 × 5 = 30 6 × 6 = 36 6 × 7 = 42 6 × 8 = 48 6 × 9 = 54
7 × 1 = 7 7 × 2 = 14 7 × 3 = 21 7 × 4 = 28 7 × 5 = 35 7 × 6 = 42 7 × 7 = 49 7 × 8 = 56 7 × 9 = 63
8 × 1 = 8 8 × 2 = 16 8 × 3 = 24 8 × 4 = 32 8 × 5 = 40 8 × 6 = 48 8 × 7 = 56 8 × 8 = 64 8 × 9 = 72
9 × 1 = 9 9 × 2 = 18 9 × 3 = 27 9 × 4 = 36 9 × 5 = 45 9 × 6 = 54 9 × 7 = 63 9 × 8 = 72 9 × 9 = 81
在上述示例中，printMultiplicationTable方法用于打印九九乘法表。当行号大于9时，递归将终止。在每行中，当列号大于行号时，将会换行并递归调用下一行的打印。在每个格子中，会打印当前行和列的乘法结果，然后递归调用下一列。
在main方法中，我们调用printMultiplicationTable(1, 1)来开始打印九九乘法表。