目录

一、可变参数

1.1定义

1.2注意

1.3示例

二、递归

2.1定义

2.2注意

2.3示例

2.4练习

---

🌈嗨！我是Filotimo__🌈。很高兴与大家相识，希望我的博客能对你有所帮助。

💡本文由Filotimo__✍️原创，首发于CSDN📚。

📣如需转载，请事先与我联系以获得授权⚠️。

🎁欢迎大家给我点赞👍、收藏⭐️，并在留言区📝与我互动，这些都是我前进的动力！

🌟我的格言：森林草木都有自己认为对的角度🌟。

---

一、可变参数

1.1定义

可变参数的语法格式是在方法参数列表中使用三个点号 ... 后跟参数类型和参数名。例如：

public static void myMethod(String... strings) {
    // 方法体
}

在这个例子中，strings 就是可变参数，它会被视为一个 String 类型的数组。

1.2注意

①        本质是数组：可变参数的本质是数组，因此在方法内部可以像操作数组一样处理可变参数。

②        参数位置限制：可变参数不能连续写多个，而且如果可变参数和其他普通参数一起使用时，可变参数必须放在参数列表的最后。

1.3示例

假设我们有一个方法需要计算任意个整数的和：

public class VarArgsExample {

    public static void main(String[] args) {
        int sumResult = sum(1, 2, 3, 4, 5);
        System.out.println("Sum: " + sumResult); 
        int sumResult2 = sum(10, 20, 30);
        System.out.println("Sum: " + sumResult2); 
    }

    // 使用可变参数计算整数的和
    public static int sum(int... numbers) {
        int result = 0;
        for (int num : numbers) {
            result += num;
        }
        return result;
    }
}

在上面的例子中，sum 方法使用了可变参数 int... numbers，允许传递任意数量的整数参数。在 main 方法中，调用 sum 方法并传递不同数量的整数参数，而无需显式创建数组。

二、递归

2.1定义

递归是指一个方法在其内部直接或间接调用自己的过程。它通常用于解决可以分解为相似子问题的问题，例如数学上的阶乘计算或者树结构的遍历。

递归可以分为两种类型：

①        直接递归：方法直接调用自身。

②        间接递归：方法通过调用其他方法间接调用自身，形成一个循环调用链。

2.2注意

①        递归必须要有出口：即递归的终止条件。如果没有终止条件或终止条件不正确，递归将会无限执行下去，导致程序出现"栈内存溢出"（Stack Overflow）错误。

②        递归次数不要太多：即使有正确的终止条件，过多的递归次数也可能导致性能问题或栈溢出。在实际编程中，通常需要根据问题的复杂性和内存限制来合理控制递归的深度。

2.3示例

以下是一个经典的递归例子，计算阶乘：

public class RecursionExample {

    public static void main(String[] args) {
        int n = 5;
        int factorial = calculateFactorial(n);
        System.out.println("Factorial of " + n + " is: " + factorial);
    }

    // 计算阶乘的递归方法
    public static int calculateFactorial(int n) {
        // 终止条件：当 n 为 0 或 1 时，阶乘为 1
        if (n == 0 || n == 1) {
            return 1;
        } else {
            // 递归调用自身
            return n * calculateFactorial(n - 1);
        }
    }
}

上面的例子求的是5的阶乘。calculateFactorial 方法使用了直接递归，它通过调用自身来计算给定数的阶乘。终止条件 if (n == 0 || n == 1) 确保了递归会在 n 减小到 1 或 0 时停止，避免了无限递归。
 

2.4练习

不死神兔的奥秘：故事得从西元1202年说起，话说有一位意大利青年，名叫斐波那契。在他的一部著作中提出了一个有趣的问题：假设一对刚出生的小兔一个月后就能长成大兔，再过一个月就能生下一对小兔，并且此后每个月都生一对小兔，一年内没有发生死亡，问：一对刚出生的兔子，一年内繁殖成多少对兔子?

每个月兔子的对数可以通过斐波那契数列来计算：

第1个月：1对兔子
第2个月：1对兔子
第3个月：2对兔子（第1、2个月的兔子生了新兔子）
第4个月：3对兔子（第2、3个月的兔子生了新兔子）
以此类推...

实现代码：

public class FibonacciRabbits {

    public static void main(String[] args) {
        int months = 12; // 假设计算12个月内兔子的繁殖对数
        int pairs = fibonacci(months);
        System.out.println("Number of rabbit pairs after " + months + " months: " + pairs);
    }

    // 计算斐波那契数列的第 n 项，表示在 n 个月后兔子的对数
    public static int fibonacci(int n) {
        if (n <= 0) {
            return 0;
        } else if (n == 1 || n == 2) {
            return 1;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }
}

fibonacci 方法使用递归来计算斐波那契数列的第 n 项。如果 n 小于等于 0，则返回 0（虽然在实际问题中，月份应该从 1 开始计数，这里用于保证代码健壮性）。如果 n 等于 1 或 2，则返回 1，因为在第一个月和第二个月只有一对兔子。对于其他月份，递归调用 fibonacci(n - 1) + fibonacci(n - 2) 来计算当前月份兔子对数，这正是斐波那契数列的定义。

从运行截图可知，经过12个月后，一开始只有一对兔子的情况下，共繁殖出了144对兔子。

通过这种递归方式，可以很方便地计算任意月份内兔子对数，但需要注意，对于大的月份（如超过40个月），递归可能会变得效率低下，这时可以考虑使用迭代方式实现斐波那契数列来提高性能。

---