2. /**
    3.  * 递归方法练习
    4.  *
    5.  *  递归方法: 一个方法体内调用他自身
    6.  *      1 方法递归包含了一种隐式的循环,他会重复执行某段代码,但这种重复执行无需循环控制
    7.  *      2 递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环
    8.  */
    9. public class Recursion {
    12.     public static void main(String[] args) {
    14.         int sum = 0;
    15.         // for循环求1-100自然数的和
    16.         for (int i = 1; i <= 100; i++) {
    17.             sum+=i;
    18.         }
    19.         System.out.println("sum = " + sum);
    20.         // 递归方法求1-100自然数的和
    21.         Recursion recursion = new Recursion();
    22.         int recursionSum = recursion.getSum(100);
    23.         System.out.println("recursionSum = " + recursionSum);
    25.         // 已知数列 f(0) = 1 f(1) = 4 f(n+2) = 2*f(n+1) + f(n) 求f(10)
    26.         int f = recursion.f(3);
    27.         System.out.println("f = " + f);
    28.     }
    30.     /**
    31.      * 求f(10)
    32.      * @param n
    33.      * @return
    34.      */
    35.     public int f(int n) {
    37.         if (n == 0 ) {
    38.             return 1;
    39.         } else if (n == 1){
    40.             return 4;
    41.         } else {
    42.             return 2 * f(n - 1) + f(n - 2);
    43.         }
    44.     }
    46.     /**
    47.      * 使用递归方法
    48.      * 求从n到1的和
    49.      * @param n
    50.      * @return
    51.      */
    52.     public int getSum(int n) {
    54.         if (n == 1) {
    55.             return 1;
    56.         } else {
    57.             return n + getSum(n - 1);
    58.         }
    59.     }
    61. }