java递归

递归：一个过程（方法）直接或间接的调用自己本身，这个过程叫做递归。

package demo;
public class Demo {
   public static void main(String[] args) {
Demo5 demo=new Demo5();
int num=demo.test(3);//int num=demo.test(4);int num=demo.test(5);
System.out.println(num);
   }
}
class Demo5 {
  public int test(int a){
       int result;
       if(a==1)｛
       return 1;
       ｝
      //调用test方法本身，实现递归
result=test(a-1)*a;
return result;
  }
}

这些结果得来的过程是这样的：

1.当参数是3时，也就是int num=demo.test(3)；这个时候会进入到test方法中，首先经过if判断a！=1，因此直接走下一步，也就是result=test(3-1)*3,即result=test（2）*3；

那么上一步中result=test（2）*3中的test（2）就要进行替换，结果是result=test(1)*2*3；

走到这一步以后，程序并没有结束，因为这里边依旧还有test方法，那么会再次调用test，再次if判断，这时候a==1，则return 1；也就是test（1）=1；

那么，上边的结果将会再次变化,即：num=result=test（1）*2*3=1*2*3=6。这就是当参数是3的时候，结果是6的递归运行过程。

2.同样的，当参数是4的时候，也就是int num=demo.test(4)；首先a！=1，那么运行到下一步就是result=test（3）*4；紧接着，test（3）之后的运行步骤就和参数是3的时候一样，那么最终的结果就是：num=result=test（3）*4=1*2*3*4=24；

3.那么当参数是5的时候，按照上边的步骤，也就是将会在最开始的时候编程test（4）*5，那么结果就是24*5=120.

再例如下边的求累加和的例子：

package demo;
public class Test1 {
   public static void main(String[] args) {
Demo11 demo=new Demo11();
int num=demo.test(3);//int num=demo.test(4);int num=demo.test(3)
System.out.println(num);
   }
}


class Demo11{
public int test(int n){
int sum;
if(n>0){
                     //调用test方法本身实现递归
sum=n+test(n-1);
return sum;
}else{
return 0;
}
}
}   

这个例子是求比我们指定的正整数小的所有正整数的和，在Demo11类中的test方法中又调用了test方法本身，这里用到了递归。

在这个例子中，参数是3的时候，结果是6；参数是4的时候，结果是10；参数是5的时候，结果是15。它的具体实现过程是这样的：

1.当参数是3的时候，也就是n=3，首先if判断n>0,那么sum=3+test（2）；紧接着test（2）再次if判断n>0,结果是2+test（1）；那么整个sum结果就会变成sum=3+test(2)=3+2+test(1)；

再然后，继续test（1），结果是1+test（0）；再然后继续test（0），n=0，return 0，结果是0；那么整个sum的结果就是sum=3+2+1+0=6。

2.当参数是4的时候，n=4，同样的，首先是sum=4+test（3），然后就是重复test（3）的步骤，结果是sum=4+test（3）=4+3+2+1+0=10。

3.再到参数是5的时候，n=5，那么一开始if之后就是sum=5+test(4)；然后sum=5+4+3+2+1+0=15。

我们以前读书的时候学过从1加到100的累加和，结果是5050，那么在这里如果把参数设为100，结果也是5050，是完全符合的，而计算的步骤也和上边的一样。

递归的过程实际上可以看成是不断的调用不断的替换的过程，有人认为递归的优点是：采用递归算法比采用迭代算法要更加清晰和简单。

在编写递归的时候，必须要使用if在递归调用不执行的时候强制方法返回，否则程序将永远不返回。