怎么样用递归法求一个数的阶乘啊，求指教？

1. 
   
2. public class test {
   
3. 
   
4.         /**
   
5.          * 用于测试
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 for(int i=1; i<10; i++){
    
11.                         System.out.println(i + "的阶乘为：" + getFactorial(i));
    
12.                 }
    
13.         }
    
14.         /**
    
15.          * 创建得到阶乘的方法
    
16.          * @param n 传入要得到几的阶乘
    
17.          * @return 得到n的阶乘数
    
18.          */
    
19.         public static int getFactorial(int n){
    
20.                 if(n == 1){
    
21.                         return 1;
    
22.                 }
    
23.                 return n*getFactorial(n-1);
    
24.         }
    
25. }
    

复制代码

自己做的一个小练习，给你看看。希望对你有帮助。

1. public class RecursionTest {
   
2. 
   
3.         /**
   
4.          * 做一个小练习，怎么用递归法求一个阶乘运算。
   
5.          *
   
6.          * 需求：1到5的相乘
   
7.          *
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 System.out.println(method(5));               
    
11.         }
    
12.         public static int method(int i){
    
13.                 if (i == 1) {
    
14.                         return i;
    
15.                 }
    
16.                 return i * method(i - 1);  
    
17.         }
    
18. }

复制代码

/*
* 递归：方法定义内部调用方法本身的现象被称为递归。
*
* void show()
* {
*                 show();
* }
*
* 注意：
*                 递归一定要有出口条件
*                 递归的次数不能过多       
*/
public class DiGuiDemo {
        public static void main(String[] args) {
                // 求5的阶乘
                int sum = 1;
                for (int x = 2; x <= 5; x++) {
                        sum *= x;
                }
                System.out.println(sum);

                System.out.println("********************");
                // 采用递归做
                DiGuiDemo dgd = new DiGuiDemo();
                System.out.println(dgd.jc(5));
        }

        // 递归求阶乘
        /*
         * 当n等于1的时候，结果就是1. 当n不等于1的时候，结果是:n*(n-1)!
         */
        public int jc(int n) { //5 - 4 - 3 - 2 - 1
                if (n == 1) {
                        return 1;
                } else {
                        return n * jc(n - 1);
                        //5*jc(4)
                        //5*4*jc(3) 5*4*6
                        //5*4*3*jc(2) 5*4*3*2
                        //5*4*3*2*jc(1)   1
                }
        }

　　递归做为一种算法在程序设计语言中广泛应用.是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现像.
　　程序调用自身的编程技巧称为递归（ recursion）。
注意：
　　(1) 递归就是在过程或函数里调用自身;
　　(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
递归算法一般用于解决三类问题：
　　(1)数据的定义是按递归定义的。(Fibonacci函数)
　　(2)问题解法按递归算法实现。(回溯)
　　(3)数据的结构形式是按递归定义的。(树的遍历，图的搜索)
以下是我求的1到100以内所有数的阶乘的和：
       public int jiecheng(int n)//第n个数的阶乘
        {
            if (n == 1)
                return 1;
            else if (n == 2)
                return 2;
            else
                return n * jiecheng(n - 1);

        }
        public int sumjiecheng(int n)//n个阶乘的和
        {
            if (n == 1)
                return 1;
            else if (n == 2)
                return 3;

            else
                return jiecheng(n) + sumjiecheng(n - 1);
       }
最后调用：sumjiecheng（100）；（计算出1到100以内所有数的阶乘的和）
我们可以调用：jiecheng（8），求的是8的阶乘。