java递归查看有几个上级 java递归次数限制

递归概念&分类&注意事项：

递归：指在当前方法中调用自己的这种现象

递归的分类：直接递归和间接递归

直接递归：方法自身调用自己

间接递归：A方法调用B方法，B方法调用C方法，C方法调用A方法

注意事项：

递归一定要有条件限定，保证递归能够停下来，否则会发生栈内存溢出

在递归中虽然有限定条件，但是递归次数不能太多哦，否则也会发生栈内存溢出

构造方法，禁止递归。

public class Demo01Recursion {
    public static void main(String[] args) {
        //a();
        b(1);
    }
    //递归中虽然有限定条件，但是递归次数不能太多哦，否则也会发生栈内存溢出
    private static void b(int i) {
        System.out.println(i);
        if(i==20000){
            return;//结束方法
        }
        b(++i);
    }
    //构造方法，禁止递归。编译报错：构造方法是创建对象使用的，一直递归会导致内存中有无数个对象，直接编译报错
    public Demo01Recursion() {
        //Demo01Recursion();
    }

    //递归一定要有条件限定，保证递归能够停下来，否则会发生栈内存溢出
    private static void a() {
        System.out.println("a方法");//栈内存溢出异常
        //a方法会在栈内存中，一只调用a方法，会导致栈内存中有无数个a方法，方法太多了就会超出栈内存的大小，就会导致内存溢出的错误
        //当一个方法调用其他方法的时候，被调用的方法没有执行完毕，当前方法会一直等待调用的方法
        //执行完毕才会继续执行
        a();
    }
}

递归使用前提：

当调用方法的时候，方法的主体不变，每次调用方法的参数不同，可以使用递归

练习-1-使用递归计算1-n之间的和：

/*
* 练习：
* 使用递归计算1-n的和
* */
public class Demo02Recursion {
    public static void main(String[] args) {
        int s = sum(100);
        System.out.println(s);//5050
    }
    /*
    * 定义一个方法，使用递归计算1-n的和。
    * 使用递归必须明确：
    * 1.递归的结束条件
    * 获取到1的时候结束
    * 2.递归的目的
    * 获取下一个被加的数字（n-1）
    * */
    public static int sum(int n){
        if(n==1) {
            return 1;
        }
        return n+sum(n-1);
    }
}
注意：使用递归求和，main方法调用sum方法，sum方法会一直调用sum方法，导致在内存中有多个sum方法（频繁的创建方法，调用方法，销毁方法），效率低下。所以仅仅是计算1-n之间的和，不推荐使用递归，使用for循环即可

练习2-使用递归计算阶乘：

/*
* 递归求阶乘
* */
public class Demo03Recursion {
    public static void main(String[] args) {
        int j = jieCheng(5);
        System.out.println(j);
    }
    /*
    * 递归结束的条件：
    * 获取到1的时候结束
    * 递归的目的：
    * 获取下一个被乘的数字n-1
    * */
    public static int jieCheng(int n){
        if(n==0) {
            return 1;
        }
        return n*jieCheng(n-1);
    }
}

练习3-递归打印多级目录：

public class Demo04Recursion {
    public static void main(String[] args) {
        File file=new File("D:\\abc");
        getAllFile(file);
    }
    /*
    * 定义一个方法，参数传递File类型的目录
    * 方法中对目录进行遍历
    * */
    public static void getAllFile(File dir){
        System.out.println(dir);//打印被遍历的目录名称
        File[] files = dir.listFiles();
        for (File file : files) {
            //对遍历得到的File对象 file进行判断
            if(file.isDirectory()){
                //file是一个文件夹，则继续遍历这个文件夹
                //直接调用getAllFile方法即可：递归（自己调用自己）。
                getAllFile(file);
            }else {
                System.out.println(file);
            }
        }
    }
}

综合案例：文件搜索：

public class Demo05Recursion {
    public static void main(String[] args) {
        File file=new File("D:\\abc");
        getAllFile(file);
    }
    /*
    * 定义一个方法，参数传递File类型的目录
    * 方法中对目录进行遍历
    * 只要.txt结尾的文件
    * */
    public static void getAllFile(File dir){
        //System.out.println(dir);//打印被遍历的目录名称
        File[] files = dir.listFiles();
        for (File file : files) {
            //对遍历得到的File对象 file进行判断
            if(file.isDirectory()){
                //file是一个文件夹，则继续遍历这个文件夹
                //直接调用getAllFile方法即可：递归（自己调用自己）。
                getAllFile(file);
            }else {
                //只要.txt结尾的文件
                /*
                * 1.把File对象f，转化为字符串对象
                * */
                //String name = file.getName();
                //String path = file.getPath();
                //String s = file.toString();
                //2.调用String类中的方法endWith判断字符串是否以.txt结尾
                //boolean b = s.endsWith(".txt");
                //3.如果是以.txt结尾的文件，则输出
                /*if(b){
                    System.out.println(file);
                }*/
                if(file.toString().toLowerCase().endsWith(".txt")){
                    System.out.println(file);
                }
            }
        }
    }
}