有人可以解释这个代码

Question

这里是第一类

公共类Number {

private static int Result; 

public Number(int X){ 

if(X == 0){ return; } 

Result += X; 

Number another_number = new Number(X-1); 

} 

public static void Clear(){ 

Result = 0; 

} 

public static int getResult(){ 

return Result; 

} 

}

这里是第二类 公共静态无效的主要（字串[] args）{

Number.Clear(); 

    Number x = new Number(5); 

    System.out.println("The result is " + Number.getResult()); 

    Number y = new Number(5); 

    System.out.println("The result is " + Number.getResult()); 

    Number.Clear(); 

    Number z = new Number(5); 

    System.out.println("The result is " + Number.getResult()); 

    } 

起初我以为答案是：

The result is 9. (Because 10-1 is 9) 
The result is 13. (Because 9+5 -1 is 13) 
The result is 4. (Because 5-1 is 4). 

但实际上答案是：

The result is 55 
The result is 70 
The result is 15 

这难倒我。我知道我错过了一些大概念，但我无法弄清楚。我已经和另外3个人交谈过，他们也很难过。如果有人能帮助我们，那会很棒。

Answer 1

当您实例化一个Number对象时，将递归调用Number(int X)构造函数。

public Number(int X) 
{ 
    if (X == 0) { return; } 

    //This will increase result by X 
    Result += X; 

    //This will instantiate a new Number which will call back into this constructor 
    Number another_number = new Number(X - 1); 

} 

由于每个构造函数被调用时，我们增加static变量Result我们会从1到X添加所有号码Result。所以，任何时候你创建的主类结果的新Number对象基本上是由下式表示：

Result = Result + X + (X-1) + (X-2) + ... +1 

由于主要开始于Number.Clear()，Result会从0开始。然后当main方法被调用，它创建的第一Number对象的结果应该是15：

Number x = new Number(5); //This will result in Result = 0 + 5 + 4 + 3 + 2 + 1 

当所述第二数量是由，Result应为30：

Number y = new Number(5); //This will result in Result = 15 + 5 + 4 + 3 + 2 + 1 

最后，我们打电话到Number.Clear()并创建一个新Number对象：

Number z = new Number(5); //This will result in Result = 0 + 5 + 4 + 3 + 2 + 1 

Answer 2

你缺少大的概念是构造函数调用本身在该行

Number another_number = new Number(X-1); // new Number calls Number constructor. 

所以，如果你新Number(5)，该阶段如下

Result += 5;  // Result is 5 
new Number(4); 
Result += 4;  // Result is 9 
new Number(3); 
Result += 3;  // Result is 12 
new Number(2); 
Result += 2;  // Result is 14 
new Number(1); 
Result += 1;  // Result is 15 
new Number(0); // stops because X == 0 

（顺便说一句，您提到的结果是指在编辑之前问题的原始版本）。

Answer 3

您正在从构造函数更新一个静态int。

我不明白你的价值。我看15，30，15

每次调用构造函数时，使用的是递归，直到你达到0

在第一个构造函数调用添加递减一系列数字，您要添加5， 4,3,2,1得到15的结果。然后在不清除结果的情况下，再次添加5,4,3,2,1得到总数30.然后总和被清除，并且第一个结果再次看到15。

你的代码注释：

private static int Result; // static, so the value is kept between initialised objects. 

public Number(int X) 
{ 

    if (X == 0) 
    { 
     return; // Return, and so end the recursion. 
    } 

    Result += X; // Add x to the result 

    Number another_number = new Number(X - 1); // Recurse into the constructor with x-1 

} 

Answer 4

每次调用构造函数，静态场Result通过参数的值递增。之后，构造函数会再次调用自己，但参数少一个。重复这个过程，直到达到0的参数后，什么也没有发生。

所以，当你写new Number(5)，您可以通过5增加Result，然后通过4，然后通过3，然后通过2，最后由1。所以你总共增加了Result15（1+2+3+4+5）。

当您拨打Number.Clear()时，您将Result的值重置为0。因为它是第一个施工前重置了，第三过，但是没有前一秒，你的输出应该是这样的：

The result is 15 
The result is 30 
The result is 15 

如果你正在

The result is 55 
The result is 70 
The result is 15 

它意味着你有写new Number(10)第一次和new Number(5)第二次和第三次。

Answer 5

公共静态无效的主要（字串[] args）是不是第二个“类”，它是类号码的主要方法。

如果你把第二个“类”公共静态无效的主要（字串[] args）{...}类号内部并运行它，结果如下：

The result is 15 
The result is 30 
The result is 15 

的正确的代码是

class Number { 
     private static int Result; 

     public Number(int X){ 
     if(X == 0){ return; } 
     Result += X; 
     Number another_number = new Number(X-1); 
     } 

     public static void Clear(){ 
     Result = 0; 
     } 

     public static int getResult(){ 
     return Result; 
     } 

     public static void main(String[] args) { 
     Number.Clear(); 
     Number x = new Number(5); 
     System.out.println("The result is " + Number.getResult()); 
     Number y = new Number(5); 
     System.out.println("The result is " + Number.getResult()); 
     Number.Clear(); 
     Number z = new Number(5); 
     System.out.println("The result is " + Number.getResult()); 
     } 
    }