Java 递归！I'；我创建了一个方法，可以先倒计时，然后再倒计时到某个数字，但我一直被困在一个无限循环中

因此，我目前正在使用递归为赋值创建一个方法。我需要取一个整数，然后向下打印直到它达到0。在那之后，我需要继续打印，直到它达到原始数字，然后停止。这是到目前为止我的代码

 public static void recursivePrinter(int levels)
{
   final int start = levels;

    if (levels < start ) {
        System.out.println("Going up! " + levels);
        recursivePrinter(levels + 1);
    }
    else {
        System.out.println("Going down! " + levels);
        recursivePrinter(levels - 1);
    }
    return;
}

publicstaticvoid递归打印机（int级别）
{
最终整数开始=级别；
如果（级别<开始）{
System.out.println（“上升！”+级别）；
递归打印机（级别+1）；
}
否则{
System.out.println（“下降！”+级别）；
递归打印机（级别-1）；
}
返回；
}

您没有到达返回点；陈述代码总是放在else语句中。要跟踪起始编号，可以使用全局变量。此外，还需要添加一个递归应该完成的条件。所以你可以试试这样的东西：

static int start = 10;


     public static void recursivePrinter(int levels)
         {


             if (levels < start ) {
                 System.out.println("Going up! " + levels);
                 recursivePrinter(levels + 1);
             }
             else {
                 System.out.println("Going down! " + levels);
                // recursivePrinter(levels - 1);
                 start-- ;
             }
             return;
         }

static int start=10；
公共静态无效递归打印机（int级别）
{
如果（级别<开始）{
System.out.println（“上升！”+级别）；
递归打印机（级别+1）；
}
否则{
System.out.println（“下降！”+级别）；
//递归打印机（级别-1）；
开始--；
}
返回；
}

试图提供一个有意义的答案，以帮助未来的访问者（与上述问题的评论线程相反）

最初的问题有两个方面：

该方法没有不递归调用自身的条件。这将导致无限递归。方法停止递归必须始终有某种条件

该方法在本地存储了一个它不需要的值，并且逻辑错误地假设对该方法的每次调用的值都不会不同

本质上，递归方法几乎总是遵循基本结构：

method(argument) {
    terminating condition;
    state change or method action;
    recursive call;
}

myMethod(level) {
    // terminating condition
    if level is 0
      return

    // method action
    print level

    // recurse
    myMethod(level - 1)
}

根据状态更改或方法操作，这可能会稍微复杂一些。但基本成分通常以某种形式存在

在您的例子中，

参数

是一个整数，

终止条件

正在测试该整数是否为已知值，

状态更改

正在更改该整数，

方法操作

正在打印该整数，

递归调用

正在使用新整数调用该方法

根据您的上述评论：

它应该从3（3，2，1）倒计时，然后回到3（1，2，3）

考虑以下伪代码（以免为您做功课）结构：

method(argument) {
    terminating condition;
    state change or method action;
    recursive call;
}

myMethod(level) {
    // terminating condition
    if level is 0
      return

    // method action
    print level

    // recurse
    myMethod(level - 1)
}

这将是一个很好的时间来逐步检查调试器中的代码，并查看递归方法调用的实际功能。每次调用该方法时，它都是一个独立的操作，不知道该方法的任何其他调用。它正在“构建一个堆栈”来调用自己。当达到终止条件时，堆栈将“展开”，并且这些调用将以相反的顺序彼此返回

有鉴于此，打印“倒计时”数字是使用以下方法再次打印的自然结果：

myMethod(level) {
    // terminating condition
    if level is 0
      return

    // method action
    print level

    // recurse
    myMethod(level - 1)

    // more method action
    print level
}

---

最后一个操作只是第二次打印该值。但是它在递归调用之后会这样做，因此在递归调用中完成所有较低数字的打印之后，不管有多少个数字。

您的代码在任何时候都不会引用

0

，这应该是一个线索。此外，如果您将级别分配给start，然后检查

级别

，那么它自然永远不会为真。您永远不会结束递归。这里没有不再次调用递归方法的条件。在你的方法中必须有一些逻辑来检查当前状态并决定不再调用它自己。此外，此代码是否始终执行

else

块？在代码中的任何点都不检查是否为0。你只需降低一级，重置当前级别，然后重复。你可以有一个有两个变量作为参数的方法，

start\u level

和

current\u level

，并且在某个点上有一个条件（例如，

current\u level==0

），你不继续递归。首先你需要原始值。您可以将其作为参数传递，因此将方法签名更改为

publicstaticvoidrecursiveprinter（int-currentLevel，int-maxLevel）

@David从现在开始，我不这么认为，但应该是这样的。