递归：一个过程（方法）直接或间接的调用自己本身，这个过程叫做递归。
例如这样一个小程序：
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;
}
}
这个程序中，类Demo5中的test方法里边又调用了test方法本身，这就是递归。在main方法中运行的时候，当参数是3时，输出的num结果是6；参数是4时，结果是24；参数是5时，结果是120.
这些结果得来的过程是这样的：
1.当参数是3时，也就是int num=demo.test(3)；这个时候会进入到test方法中，首先经过if判断a！=1，因此直接走下一步，也就是result=test(3-1)*3,即result=test（2）*3；
因为这里又有test方法，参数是2，因此会在这里再次调用test方法，下一步再if判断，依旧是a！=1，则test（2）的结果就是test（1）*2；
那么上一步中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在递归调用不执行的时候强制方法返回，否则程序将永远不返回。
例如这样一个小程序：
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;
}
}
这个程序中，类Demo5中的test方法里边又调用了test方法本身，这就是递归。在main方法中运行的时候，当参数是3时，输出的num结果是6；参数是4时，结果是24；参数是5时，结果是120.
这些结果得来的过程是这样的：
1.当参数是3时，也就是int num=demo.test(3)；这个时候会进入到test方法中，首先经过if判断a！=1，因此直接走下一步，也就是result=test(3-1)*3,即result=test（2）*3；
因为这里又有test方法，参数是2，因此会在这里再次调用test方法，下一步再if判断，依旧是a！=1，则test（2）的结果就是test（1）*2；
那么上一步中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在递归调用不执行的时候强制方法返回，否则程序将永远不返回。
