【方法的递归调用】

public class abc{
    public static void main(String[] args) {
      T t = new T();
      t.test(4);
    }
}
class T{
    public void test(int n){
        if (n > 2){
            test(n -1);
        }
        System.out.println("n=" + n);
    }
}

public class abc{
    public static void main(String[] args) {
      T t1 = new T();
      int res = t1.factorial(5);
        System.out.println("res ="+ res);
    }
}
// factorial 阶乘
class T {
    public int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
           return factorial(n - 1) * n;
        }
    }
}

内容简介：

1.  方法的递归调用

2.  方法的递归调用的注意问题

1.    方法的递归调用

方法的递归调用指的是一个方法自己调用自己的情况，利用递归调用可以解决一些重复且麻烦的问题，那么在进行方法递归调用的时候，一般需要考虑以下几点问题。

2.     方法的递归调用的注意问题

第一点，一定要设置方法递归调用的结束条件；

第二点，每一次调用的过程之中一定要修改传递的参数条件。

范例：实现一个1~100的累加，这个过程实际上曾经使用过while语句来完成，代码如下：

public class JavaDemo {
public static void main(String args[]) {
int sum = 0 ;
int x =1;
while（x<=100）{ //循环的结束条件
sum += x;
  
x++;  //修改每一次循环的变量
}
System.out.println(sum);
}
}

其运行结果如下：

而这个程序代码也是可以通过递归的形式是来实现的，如果是递归，那就有可能实现1~100，有可能实现1~200，甚至可能实现1~500。就是说可能实现无数的数据的累加，那么其代码如下： 

public class JavaDemo {
public static void main(String args[]) {
System.out.println(sum(100)) ;
}

public static int sum(int num) {    //执行累加
if（num==1）{//不累加了
return 1 ;|
}
return num+ sum(num-1)；//递归调用
}
}

其执行结果如下：

其中num==1是设的一个结束条件，如果num==1的时候，就不累加，直接return 1就结束了。下面对此代码进行一些简单的分析处理：比如sum方法，sum这个方法一定是由两个地方发起作用，一个是主方法，一个是sum自己，所以

第1次执行sum（），主方法执行，主方法执行的过程中return的作用就是主方法如果传100过来，不会执行，因为不满足条件，所以那么相当于return100+sum（99）；

第2次执行sum（），sum（）递归调用，那么这时就是return99+sum（98）；

直到第99次执行sum（），sum（）递归调用，那么就是return2+sum（1）；

第100次执行sum（），还是sum（）递归调用，这时return 1被触发了；

整体形式就变成了return 100+99+98+… …+2+1；递归操作虽然可以简化的调用，但是在实际的开发之中，所编写的代码可能会很少出现有递归情况。就是说在写代码的确会有递归，但是递归不是写的，是由系统提供的。大部分情况下考虑的都只是一些简单的处理逻辑，这个就是现在的开发过程。递归少去使用还有另外一个原因：如果处理不当则会造成内存溢出，主要就是栈溢出。

但说到递归，再说一个更有代表性的程序，如下：

阶乘的过程实际上也是一个往上涨倍数的过程，1的阶乘就是1，2就是1×2，3的阶乘是6... ... 90的阶乘就相当庞大了，这个数据只有double能装下。

在进行阶乘计算的时候必须要考虑选择的数据类型，肯定不能够使用long或int，只能够使用double，而且如果阶乘更大，double也装不下，就要采用其他方式来处理了。

90的阶乘的代码如下：

public class JavaDemo {
public static void main(String args[]) {
System.out.println(fan(90));
}
public static double fan(int num){// 执行累加
if（num==1）{//不累加了
return 1 ;
}
return num*fan(num-1)；//递归调用
}
}

 其执行结果如下：

public class JavaDemo {
public static void main(String args[]) {
System.out.println(sum(90)) ;
}
public static double sum(int num) {
if (num==1)(
    return 1 ;
}
return fan(num) + sum (num - 1) ;
}
public static double fan(int num){//执行累加
if（num==1）{//不累加了
return 1 ;
}
return num*fan(num-1)；//递归调用
}
}

 所以这个过程可以直接采用递归的调用处理形式来完成，实际上有一部分递归都是可以通过循环来完成，但是如果使用递归要比使用循环结构看起来更加清晰一些。不过一般情况下，知道递归这种形式即可。