Java的递归深度有关问题

Java的递归深度问题
Java新手，帮女儿解一道奥数题，编程了，题目如下：
有一串数，第一个是6，第二个是3，从第二个数起，每个数都比它前面的那个数和后面的那个数的和小5。那么这串数从第一个数到第200个数为止的这200个数之和是多少？
用了一个递归！想看看第200个数是多少？
public class test{

private static int fn(int n){
if (n == 0){
return 6;
}
else if (n == 1){
return 3;
}else{
return fn(n-1)+5-fn(n-2);
}
}

public static void main(String[] args) {
System.out.println(fn(199));
}

}
电脑就卡机了！后来试着把199改为15，程序运行没问题！
接着测试，发现数字大于50，就卡机！40就运行正常，请大侠们看看，啥问题？
Java没有这么脆弱吧？Eclipse LUNA
------解决思路----------------------
我实验了一下你的方法，确实太慢了，输出后发现，用递归的方式很多步骤是重复计算的，这种用递推公式表示的数列的操作，还是用循环方式速度快啊，因为上一步的计算结果可以直接够下一步使用，不重复计算。下面是我的实现代码。

import java.util.Calendar;

public class Test {
	public static void main(String[] args) {
		Test test = new Test();
		long s = Calendar.getInstance().getTimeInMillis();
		for (int j = 1; j <= 300000; j++) {
			System.out.println("第 " + j + " 项：" + test.getItem(j));
			System.out.println("前 " + j + " 项和：" + test.sumN(j));
			System.out.println("==============");
		}
		long e = Calendar.getInstance().getTimeInMillis();
		System.out.println("用时：" + (e - s) / 1000 + "秒。");//用时：98秒。
	}

	/**
	 * 求由递推公式(a[0]=6, a[1]=3, a[n] = a[n-1] - a[n-2] + 5)确定的数列的第n项的值
	 * @param n
	 * @return
	 */
	private int getItem(int n) {
		int result = 0;
		if (n == 1) {
			return 6;
		} else if (n == 2) {
			return 3;
		} else {
			int n_2 = 6;
			int n_1 = 3;
			for (int i = 3; i <= n; i++) {
				result = n_1 - n_2 + 5;
				n_2 = n_1;
				n_1 = result;
			}
		}
		return result;
	}

	/**
	 * 求由递推公式(a[0]=6, a[1]=3, a[n] = a[n-1] - a[n-2] + 5)确定的数列的前n项和
	 * @param n
	 * @return		
	 */
	private int sumN(int n) {
		if (n == 1) {
			return 6;
		} else if (n == 2) {
			return 9;
		} else {
			int n_2 = 6;
			int n_1 = 3;
			int result = n_1 + n_2;
			int tmp = 0;
			for (int i = 3; i <= n; i++) {
				tmp = n_1 - n_2 + 5;
				n_2 = n_1;
				n_1 = tmp;
				result += tmp;
			}
			return result;
		}
	}
}