我写了一个累加一个从0到指定值的求和的递归方法，代码如下：

1.         public static int getSum(int maxValue) {
   
2.                 if (maxValue == 1)
   
3.                         return 1;
   
4.                 else {
   
5.                         return maxValue + getSum(maxValue-1);
   
6.                 }
   
7.         }

复制代码

运行可以得到正确的答案，但是我能不能把else里面的getSum(maxValue-1)改成getSum(maxValue--)呢？
改过运行时内存溢出，为什么不行啊？

i=3
a=i++
a=3，i=4

i=3
a=++i
a=4，i=4



运算先后顺序问题……
return maxValue + getSum(maxValue--);
先getSum(maxValue）再maxValue--
无限循环了

这里有一个问题，就是maxValue--和--maxValue的区别。
--maxValue是把maxValue的值先减一再赋给getSum.
maxValue--是先把maxValue的值赋给getSum.然后再减一，但是减一的值没有重新赋给maxValue，所以getSum的得到的maxValue一直都是原来的数，进入了无限循环。所以就内存溢出了。所以把maxValue--改成--maxValue就行了

1. public static int getSum(int maxValue) {
   
2. 
   
3.                 if (maxValue == 1)
   
4. 
   
5.                         return 1;
   
6. 
   
7.                 else {
   
8. 
   
9.                         return maxValue + getSum(--maxValue);
   
10. 
    
11.                 }
    
12. 
    
13.         }
    

复制代码

递归就是自己调用自己,如果是-1也就是循环到(maxValue-1)-1,如果是--哪么每次过来就自身 - 一次哪么也就成了死循环.所以就溢出了呀!
对应的API文档:当应用程序递归太深而发生堆栈溢出时，抛出该错误。

maxValue--是先把maxValue的值做getSum的参数传进去做运算，然后再减1，getSum实际得到的参数是10，由于是递归，所以每次都是执行getSum(10)，无限循环下去了。
楼主可能没搞明白a--和--a的区别。把maxValue--换成--maxValue就可以正常运行了。

另外补充一点，“内存溢出”描述的不够具体，应该是内存中的“栈溢出”。

这就是a--与--a的区别了，a--是先参加运算，然后再自减一。而--a是先自减一，在参加运算。而你上面那个题目需要的是先自减一在运算，如果换成--maxValue应该就可以了。

其实就是--在前还是在后的问题，在后，先运算，在自减，在前，先自减，在调用。
经过修改代码：

1. public class Demo8 {
   
2.     public static void main(String args[]){
   
3.             System.out.println(getSum(10)) ;
   
4.     }
   
5.     public static int getSum(int maxValue) {
   
6.         if (maxValue == 1)
   
7.                 return 1;
   
8.         else {
   
9.                 return maxValue + getSum(--maxValue);  //修改此处，减减在前
   
10.         }
    
11.     }
    
12. }

复制代码

getSum(maxValue--)：是maxValue先被getSum方法调用，然后再自减
getSum(--maxValue)：是maxValue先自减，再被getSum方法调用

比如：如下代码输出结果
class  DiGui
{
public static void main(String[] args)
{
     int x = 3;
     get(x--);//结果为3，即先被调用了
     System.out.println(x);//结果为2，即被调用之后在自减了
}
   public static void get(int maxValue)
{
   System.out.println(maxValue);
}
}
当你将代码改为下面的时候
getSum(maxValue--)：在调用自身方法时，总是在调用你maxValue，而没有将自减后值的传递给getSum方法，这样就会永远满足不等于1的条件无限递归

所以要改为
getSum(--maxValue)：先自减，自减后的值在被方法调用，就可以了

return maxValue + getSum(maxValue--);//这里的问题。
单目运算符--在右边，是先赋值再自减，所以运行一次以后，先赋值给getSum（）再自减1，所以计算的还是原来的getSum（maxValue），陷入了死循环，
你可以改成--maxValue，先自减再赋值，就不会了

每次调用getSum(maxValue--)都会在栈内存中开辟属于下一个getSum函数的maxValue局部变量来接收值，如果传递是表达式maxValue--则会将本次maxValue的值直接赋给下一个maxValue，然后将本次的maxValue减1，这样的话每次接收的maxValue还是原来的初值，而不会执行return 1停止递归，而本次maxValue的内存并不会释放因为本次return没有执行到就去执行下一次getSum函数，这样无限循环会新建很多个maxValue直到栈内存溢出。也就是说这个递归的完成是新建了很多个maxValue来接收值，只有本次的getSum结束才会释放。



               

public class Demo8 {
    public static void main(String args[]){
        System.out.println(getSum(10)) ;
    }
    public static int getSum(int maxValue) {
        if (maxValue == 1)
            return 1;
        else {
            return maxValue + getSum(maxValue-1);  //如果maxValue为3,(maxValue-1)当前的结果是2
            return maxValue + getSum(maxValue--);  //如果maxValue为3,(maxValue--)当前的结果仍然是3,执行完这步后maxValue结果变为2
            return maxValue + getSum(--maxValue);  //如果maxValue为3,(--maxValue)当前的结果是3
        }
    }
}

所以这个问题修改应为将maxValue-1变为--maxValue

呵呵我很开心~~~

这么回事