Java：难以理解递归方法调用

Question

我制作了一个类似“Oregon Trail”的游戏，它使用“游戏结束”的方法来询问用户是否想再玩一次。

主要问题： 我的老师提到了一些模糊的东西，如果游戏循环足够多次，我们最终会得到一个 stackOverflow。这对我来说很有意义，因为游戏继续按照我的方式将方法嵌套在彼此内部，每次调用“新游戏”方法时都会添加到堆栈中，因为外部方法仍在等待完成。

我总结了一个例子来说明我的意思。假设用户输入有暂停等，我应该如何确保我的内存利用率不会随着我在其他方法中调用方法而不断增长？我认为这个词是“递归的”，这就是我的标题。

如果有人能推荐正确的处理方式，我将不胜感激。

public class Testing
{
    public static void main(String[] args) {
        System.out.println("main method");
        gameStart();
    }
    
    private static void gameStart()
    {
        System.out.println("some other method called");
        gameOver();
    }
    
    private static void gameOver()
    {
        System.out.println("game over called"); //I would ask the user if they want to play again.
        //keeping it concise to illustrate my point, instead of using an if statement
        gameStart();//starting the cycle I'm concerned about. Assume the user indicated they would like to play again.
    }
}

Answer 1

递归需要一个不会继续调用的条件。
递归最常见于方法调用自身的地方，例如计算斐波那契数列，其中

fib(n) == fib(n-1) + fib(n-2)

fib(0) 定义为 0，因此您不必计算。
fib(1) 定义为 1，因此您不必计算。
每隔一个数字由调用自身的fib() 方法计算两次，但它避免了对两个定义的情况进行递归调用，其中没有什么可计算的。在伪代码中

int fib(int n)
{
    if (n == 0) return 0; // doesnt have to recursively call
    if (n == 1) return 1; // same
    return fib(n-1) + fib(n-2);
}

在您的情况下，您有两个方法可以相互调用，但是您没有条件可以使调用从中逃脱。

有一种可能是gameOver() 仅在比赛以平局结束时调用gameStart()，类似于

public class Testing
{
    public static void main(String[] args) {
        System.out.println("main method");
        gameStart();
    }

    private static void gameStart()
    {
        System.out.println("some other method called");
        gameOver();
    }

    private static void gameOver()
    {
        System.out.println("game over called");
        if (gameTied()) {
            gameStart();
        }
    }
}

如果你只是问“你想再玩一次吗？” -- 最好在main 中完成，类​​似于

public static void main(String[] args) {
    System.out.println("main method");
    String playGame = "Yes";
    while (playGame.equalsIgnoreCase("Yes") {
        gameStart();
        playGame = ask("Play again?");
    }
}

Answer 2

为了避免无限递归，您可以切换到迭代并为当前决定如何继续的那些方法引入返回值（当前通过直接调用相应的操作）。 让这些方法返回一些符号接下来要做什么，例如使用枚举。 然后编写一个循环，根据返回值调用正确的方法。

示例（缩写，我假设您知道 Java 语法）：

enum Action { Start, ShowEnd, Quit }

主要：

Action nextAction = Action.Start;
while (action != Action.Quit)
{
    switch (action)
    {
        case Start:
            nextAction = gameStart();
            break;
        case ShowEnd:
            nextAction = gameEnd();
            break;
        // ToDo: write more actions!
        default:
            break;
    }
}

这假定每个这样的方法都会执行，直到决定下一步要采取的行动为止。

这样你的调用堆栈总是很平坦，因为执行总是返回到主方法，然后分支到其他方法。

Answer 3

当您编写递归代码时，您应该确保除了再次调用该函数之外还有某种结束条件。例如，我使用if(gamePlayedThisManyTimes <= 1) return; 为gameOver 方法添加了一个结束条件。运行以下代码时，您为方法 gameStart 提供的值将决定您玩多少游戏，gameOver 将在调用“gameStart”以最终达到递归结束条件时递减该值。

public static void main(String[] args)
{
    System.out.println("main method");
    gameStart(10);
}

private static void gameStart(int playGameThisManyTimes)
{
    System.out.println("Game " + playGameThisManyTimes + " started...");
    System.out.println("some other method called");
    gameOver(playGameThisManyTimes);
}

private static void gameOver(int gamePlayedThisManyTimes)
{
    System.out.println("game over called for " + gamePlayedThisManyTimes); //I would ask the user if they want to play again.

    if(gamePlayedThisManyTimes <= 1)
        return;
    else
        gameStart(gamePlayedThisManyTimes - 1);
}

输出

main method
Game 10 started...
some other method called
game over called for 10
Game 9 started...
some other method called
game over called for 9
Game 8 started...
some other method called
game over called for 8
Game 7 started...
some other method called
game over called for 7
Game 6 started...
some other method called
game over called for 6
Game 5 started...
some other method called
game over called for 5
Game 4 started...
some other method called
game over called for 4
Game 3 started...
some other method called
game over called for 3
Game 2 started...
some other method called
game over called for 2
Game 1 started...
some other method called
game over called for 1