Java方法递归

递归就是方法自己调用自己

以下执行会报错

public class Tset{
	public static void main(String[] args){
		doSome();
	}
	
	//以下代码虽然只有一份，但是可以被重复调用
	//只要调用 doSome 方法就会在栈内存中新分配一块所属的内存空间
	public static void doSome(){
		doSome();     //这行代码不结束，永远无法执行下一行代码
		System.out.println("草莓");
	}
}

以上程序，doSome 虽然只有一份，但是可以被重复的调用

只要调用doSome方法就会在栈内存中新分配一块所属的内存空间，没有任何弹出，一直在不断的压栈。

练习

不使用递归，计算 1 - N 的和【可以不用递归，尽量不用递归】

public class Test{
	public static void main(String[] args){
		/*
		// 1-4的和
		int n = 4;
		int sum = 0;
		for(int i = 1; i <= n; i ++){
			sum += i;
		}
		*/
		
		//直接调用方法即可
		int result = sum(4);
		System.out.println( result );
	}
	
	//单独定义一个方法，因为这是一个独立的功能，可以完成 1-N 的和
	public static int sum(int n){
		int s = 0;
		for(int i = 1; i <= n; i ++){
			s += i;
		}
		return s;
	}
}

使用递归，计算 1 - N 的和
思路：4+3+2+1

public class Test{
	public static void main(String[] args) {
		//使用递归，计算 1 - N 的和
		int a = doSome(4);
		System.out.println(a);
		int b = doSome(5);
		System.out.println(b);
	}
	public static int doSome(int n){
		if(n == 1){
			return 1;
		}
		int result = n + doSome(n - 1);
		return result;
	}
}

内存分析

不使用递归，计算 1 - N 的累积

public class Test{
	public static void main(String[] args) {
		//不使用递归，计算 1 - N 的累积
		System.out.println(m(3));
	}
	public static int m(int n){
		int a = 1;
		for(int i = 1;i <= n; i ++){
			a *= i;
		}
		return a;
	}
}

public class Test{
	public static void main(String[] args) {
		//不使用递归，计算 1 - N 的累积
		System.out.println(m(4));
	}
	public static int m(int n){
 		int a = 1;
		for(;n > 1; n --){
			a *= n;
		}
		return a;
	}
}

使用递归，计算 1 - N 的累积
思路：4 * 3 * 2 * 1

public class Test{
	public static void main(String[] args) {
		//使用递归，计算 1 - N 的累积
		System.out.println(doSome(4));
	}
	public static int doSome(int n){
 		 if( n == 1){
			 return 1;
		 }
		return n*doSome(n - 1);
	}
}

递归的内存分析

理论

1. 什么是递归？
   1. 方法自己调用自己test() { test(); }
   2. 传递和回归
2. 递归很耗费栈内存，递归算法能不用尽量不用。有些情况必须靠递归实现。例如：目录拷贝
3. 无法结束的递归在程序运行时发生错误【不是异常，是错误Error】
   java.lang.StackOverflowError栈内存溢出错误
   错误无法挽回，只有一个结果，就是 JVM 停止工作
4. 递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误
5. 递归即使有了结束条件，即使条件是正确的，也可能会发生栈内存溢出错误，因为递归的太深了