Java基础入门篇——方法和重载（十四）

一、什么是方法

方法是一段封装了特定功能的代码块，可以在程序中被多次调用和重复使用。它接受输入参数（可选）并可以返回一个值（也可以是空）。在Java中，方法用于实现特定的任务或操作，并且可以被其他部分的代码调用和重用。

2.1方法的语法格式

方法由以下几个组成部分： 

1. 方法签名：方法的名称和参数列表的组合。方法签名用于唯一地标识一个方法。

2. 参数列表：方法的输入参数，用于向方法传递数据。方法可以接受零个或多个参数。

3. 返回类型：方法返回的数据类型。方法可以是void类型（不返回任何值），也可以是其他基本类型或引用类型。

4. 方法体：方法的具体实现代码，它包括在方法调用时要执行的一系列语句。

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

方括号表示可选部分。访问修饰符指定了其他类是否能够访问该方法。返回类型是方法返回的值的数据类型。方法名是方法的唯一标识符，用于调用该方法。参数列表包含在括号中，用于传递数据给方法。方法体是方法的具体实现。 

方法示例： 

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）是指在同一个类中定义多个具有相同名称但参数列表不同的方法。

方法的重载允许我们给相似的操作赋予相同的方法名，这样可以提高代码的可读性和可维护性。通过方法的重载，我们可以根据传递给方法的实际参数类型和数量，来决定应该调用哪个具体的方法。

方法重载的规则如下：

1. 方法必须在同一个类中进行重载。
2. 方法名称必须相同。
3. 参数列表必须不同，可以有不同的参数类型、参数顺序或参数数量。
4. 方法的返回类型与重载无关，只依赖于方法名称和参数列表。

以下是一个示例，展示了方法重载的使用：

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）是指在方法的实现中调用自身的过程。

递归方法通常包含两个要素：

1. 基本情况（Base Case）：定义在递归方法中的一个条件，当满足该条件时，递归将终止并返回一个特定的结果。

2. 递归调用（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)来开始打印九九乘法表。