java - 需要帮助破译 Java 中的阶乘代码

Question

我已经看到使用我理解的 for 循环的答案，但是我最近遇到了这段代码，但我不知道它是如何工作的。

public class learn {

    public static int factorial (int N){
        if (N<=1 ) return 1; // won't this mean that "1" is returned at the end all the time?
        else return (N*factorial (N-1)); /* since there's no variable storing the sum
                                            I don't get how this is working out either, 
                                            won't it just be returned and lost?*/
    }
    public static void main(String[] args) {
        System.out.println(factorial(4));
    }
}

来自 python 背景，所以也许我对 java 中的返回存在误解......[编辑] 看起来像 return 1也是用 Python 编写的，所以这可能不是语言问题，我只是不明白递归函数是如何结束的(我知道这个过程是如何进行的——它是一个调用自身的函数)。

这是我如何(错误地)解释这段代码的例子:

1. factorial(4)被称为
2. 4 大于 1，所以 else语句将运行 -- 4*factorial(3)
3. factorial(3)被称为 - else语句再次运行 -- 3*factorial(2)
4. factorial(2)被称为 -- 2*factorial(1) .在这一点上，我们有 4*3*2*1 但事实上代码只停在 if (N<=1) return 1 处。行意味着返回 1 而不是总和，对吗？ (我显然错了，因为控制台打印了正确的数字 - 24)

Answer 1

won't this mean that "1" is returned at the end all the time?

不，它只会在 N 时返回 1小于1。(根据你的情况 if (N<=1 ) return 1; )对于所有其他情况，它递归地继续。

since there's no variable storing the sum I don't get how this is working out either, won't it just be returned and lost?

当方法返回时，它会退出当前方法并返回调用点并从那里继续。为简单起见，采用这种情况:方法 A 调用方法 B，方法 B 调用方法 C:

public void methodA(){
    print("entering method A..");   //(1)methodA invoked..
    methodB();                      //(2)call methodB
    print("exiting method A");      //(8)exit from methodB, continue from here
}

public void methodB(){               
    print("entering method B..");   //(3)mthodB invoked..
    methodC();                      //(4)call methodC
    print("exiting method B");      //(7)exit from methodC, continue from here. exit methodB
}

public void methodC(){
    print("entering method C..");   //(5)methodC invoked..
    print("exiting method C");      //(6)exit methodC, continue from whoever called methodC
}

你会得到如下输出:

entering method A..
entering method B..
entering method C..
exiting method C
exiting method B
exiting method A

---

如果你能理解方法A B 和C 的程序流程。现在试着理解一个调用“自身”的方法。

//Let say N is 3.. 
public static void main(String[] args){
    factorial(3);                    //(9)
}

public static int factorial (int N)  //(1)N:3, (3)N:2, (5)N:1
{
    if (N<=1 ) 
        return 1;                    //(6)Ret 1, return and continue from whoever called me
    else 
        return (N*factorial (N-1));  //(2), (4), (7)Ret 2*1, (8)Ret 3*2*1
}

• 在 (6) 处，它通过返回 1 退出方法并从调用此方法的地方继续。调用的地方在(7)。

• 在 (7) 处，它通过返回 N*1(即 2*1 = 2)退出该方法，并从调用此方法的地方继续。调用的地方在(8)。

• 在 (8) 处，它通过返回 N*2(即 3*2 = 6)退出该方法，并从调用该方法的地方继续。调用的地方在(9)处是main方法。