面向对象入门3（递归方法）

方法中的调用自身——

“打开一扇通往自家房间的门，房间里还有一扇同样通往自家房间的门”

本质上是一个隐藏的循环；

Alert：要避免无限递归，一定要在能出现某些情况下，不再调用方法自身

简例1：

  1. public class Recursive {
  2.     public void test(){
  3.         System.out.println("Dating");
  4.         test();
  5.     }
  7.     public static void main(String[] args) {
  8.         Recursive a=new Recursive();
  9.         a.test();
  10.     }
  11. }

Alert：要避免无限递归，一定要在能出现某些情况下，不再调用方法自身

例1改

  1. public class Recursive {
  2.     public int i;
  3.     public void test(){
  4.         i++;
  5.         if(i<=5) {
  6.             System.out.println("Dating"+i);
  7.             test();
  8.         }
  9.     }
  11.     public static void main(String[] args) {
  12.         Recursive a=new Recursive();
  13.         a.test();
  14.     }
  15. }
  16. /*
  17. Dating1
  18. Dating2
  19. Dating3
  20. Dating4
  21. Dating5
  22. */

实例1：

存在函数

f(n)=f(n+2)-2*f(n+1) , f(1)=3 ,

求f(10)

Slu: 令 N = n+2

f(N) = f(N-2) + 2*f(N-1)

  1. public class Function {
  2.     public static int fu(int a)
  3.     {
  4.         if(a==1)
  5.         {
  6.             return 2;
  7.         }
  8.         else if (a==2)
  9.         {
  10.             return 5;
  11.         }
  12.         else
  13.         {
  14.             return fu(a-2)-2*fu(a-1);
  15.         }
  16.     }
  18.     public static void main(String[] args) {
  19.         System.out.println(Function.fu(10));
  20.     }
  21. }
  22. /*
  23. 5741
  24. */

再次声明：必须要保证递归结束的条件