Java进阶（第八期）： Java中递归的的使用和递归解决一些算法问题 &&Java中的异常机制、异常的处理逻辑 && 自定义异常

Java进阶（第八期）

一、递归

1.1 递归的介绍

public static void main (String[] args) {
    // 调用递归函数
    recursionMethods();
}

public static void recursionMethods () {
    // 自己调用自己
    recursionMethods();
}

• 如果设计不合理，那么程序就会报错！栈空间溢出

• 一般都是用在解决算法的。

1.2 递归的简单练习

如下例子：

    public static void main(String[] LiuJinTao) {
        // 需求：使用递归求出 5 的阶乘
        int result = jc(5);
        System.out.println(result);     // 120
    }
    
    public static int jc (int num) {
        if (num == 1) {
            return 1;
        } else {
            return num * jc(num - 1);
        }
    }

1.3 图解递归执行流程：

• 附加练习

需求：使用递归，求1 到 n的和

        // 需求：使用递归，求1 到 n的和
        int result = sumMethod(5);
        System.out.println(result);
    }
    
    
    public static int sumMethod (int n) {
        if (n == 1) {
            return 1;
        } else {
            return n += sumMethod(n - 1);
        }
    }

1.4 使用递归完成悲波那契数列

)

    public static void main(String[] LiuJinTao) {
        // 分析可知，从第三个月开始，每隔三个月的兔子对数就是前两个月和前一个月的和
        int result = get(20);
        System.out.println(result); // 6765
    }
    
    public static int get (int mouth) {
        if (mouth == 1 || mouth == 2) {
            return 1;   // 前三个月只有一对
        } else  {
            // 从第三个月开始，每个月的对数是前面两对的和
            return get(mouth - 2) + get(mouth - 1);
        }
    }

1.5 猴子吃桃子问题

    public static void main(String[] LiuJinTao) {
        int result = handleMonkey(1);
        System.out.println(result);     // 1534
    }
    
    public static int handleMonkey (int num) {
        if (num == 10) {
            return 1;
        } else {
            // 当天的个数 = 后一天的个数 + 1 * 2
            return (handleMonkey(num +1) + 1) * 2;
        }
    }

二、异常

• 异常指的是在我们代码编译或者执行的过程中可能出现的错误。

/*
编译时异常： 编译阶段就出现的错误（语法错误除外）
: 需要在运行前，给出解决方案

运行时异常，运行期间可能会出现的错误

*/

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse("2023年12月24日"); // 这里 parse就会出现编译异常
        System.out.println(date);
        
        FileReader fr = new FileReader("D:\\java_code");    // 这里FileReader也会出现编译异常
    }

三 、异常的处理逻辑

• Java程序对异常的默认处理方式： 向上抛出。

)

3.1 try catch 捕获异常

• 代码示例：

    public static void main(String[] LiuJinTao) {
        // try catch 异常捕获 多种写法
        System.out.println("开始！");
        
        try {
            int [] arr = null;
            System.out.println(arr[10]);    // 出现异常：自动 new NullPointerException（）；
            System.out.println(20 / 0);     // 出现异常：自动 new ArithmeticException （）；
        } catch (ArithmeticException e) {   // 捕获异常：接受 ArithmeticException e
            System.out.println("捕获运算异常！");
        } catch (NullPointerException e) {  // 捕获异常：接受 NullPointerException e
            System.out.println("捕获了空指针异常！");
        } catch (Exception e) {
            System.out.println("我能捕获所有异常，兜底的处理方式！");
        }
        
        System.out.println("结束！");
        
    }

• Exception 是异常和错误的父类，所以这里使用了他去接受捕获到到的对象。（异常多态）

• 但是要注意的是： 如果有多个异常的捕获，Exception必须在最后面

开始

捕获了空指针异常

结束

使用场景练习：

    public static void main(String [] LiuJinTao) {
        Student stu = new Student();
        Scanner sc = new Scanner(System.in);
        
        
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        stu.setName(name);
        
        System.out.println("请输入学生的年龄：");
        int age = 0;
        
        while (true) {
            try {
                age = Integer.parseInt(sc.nextLine()); // 这里有问题，就会创建异常对象，然后向上抛出
                break;
            } catch (NumberFormatException e) {
                System.out.println("学生年龄输入有误，请重新输入：");
            }
        }
        stu.setAge(age);
        
        System.out.println(stu);
    }

• 再循环里面记得给出口，不然报错哦！

• 合理使用还能优化代码是不是不错啊！

3.2 throws抛出异常

• 抛出异常：将错误信息抛出去，然后终止程序！

  throw ： 抛出异常对象

  throws： 声明异常，告知需要处理掉，不然跑不了

• 学到这，问题：面临异常，是否需要暴露出来呢？

• 回答： 不需要暴露： 我们选择 try catch捕获

? 需要暴露： 选择抛出异常 throws

• 合理隐藏，合理暴露。

    public static void main(String[] LiuJinTao) throws FileNotFoundException, ParseException {
        // 如果调用异常的方法，你不给他上级说明好有问题，程序就会报错。
        method();
    }
    
    
    public static void method () throws ParseException, FileNotFoundException {    // 抛出异常，签名！
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse("abc");
        System.out.println(date);
        
        // 读取文件依旧可能会出现异常，必须处理，要么捕获处理，要么抛出。
        FileReader frd = new FileReader("D://demo.txt");
    }

throws抛出异常的使用

• 下面我给年龄的设置进行限定，如果不在我限定的范围内的话，我就抛出编译异常，如果用户在设置的时候，不处理的话，编译后执行就报错！

.png#pic_center)

    public void setAge (int age) throws Exception{
        if (age >= 0 || age <= 120) {
            this.age = age;
        } else {
            throw new Exception("年龄输入有误，需要符合在0 - 120之间的年龄");
        }
    }

• 下面，stu.setAge 必须对我抛出的异常进行处理，如果不处理，运行不了

    public static void main(String [] LiuJinTao) throws Exception {
        Student stu = new Student();
        Scanner sc = new Scanner(System.in);
        
        
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        stu.setName(name);
        
        System.out.println("请输入学生的年龄：");
        int age = 0;
        
        while (true) {
            try {
                age = Integer.parseInt(sc.nextLine()); // 这里有问题，就会创建异常对象，然后向上抛出
                break;
            } catch (NumberFormatException e) {
                System.out.println("学生年龄输入有误，请重新输入：");
            }
        }
        stu.setAge(age);
        
        System.out.println(stu);
    }

我给我的上级加了个签名，throws ，说明我这里有异常。

加了后，允许程序编译运行，但是你要是不符合要求，我就给你如下提示：

---

• 但是，这样处理的话，用户怎么看咧，我们是不是应该处理掉呢？
• 因为我们使用的是抛出异常，错误的信息直接被抛出来了，所以这里我们得使用捕获异常

    public static void main(String [] LiuJinTao) {
        Student stu = new Student();
        Scanner sc = new Scanner(System.in);
        
        
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        stu.setName(name);
        
        System.out.println("请输入学生的年龄：");
        int age = 0;
        
        while (true) {
            try {
                age = Integer.parseInt(sc.nextLine()); // 这里有问题，就会创建异常对象，然后向上抛出
                stu.setAge(age);
                break;
            } catch (NumberFormatException e) {
                System.out.println("学生年龄输入有误，请重新输入：");
            } catch (Exception e) {
                System.out.println("年龄输入应在 0 - 120 范围内！");
            }
        }

• 到现在，我相信大家都能明白该如何选择两种异常处理吧！

四、自定义异常

• 能够让自己写代码变得更加严谨， 毕竟Java不可能什么异常都能考虑到；

1、 先定义一个异常类,继承父类，super初始化数据

public class StudentAgeException extends Exception{
    public StudentAgeException (String Message) {
        super(Message);
    }
}

2、 给异常处理处进行自定义类异常抛出

    public void setAge (int age) throws StudentAgeException {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            throw new StudentAgeException("年龄输入有误，需要符合在0 - 120之间的年龄");
        }
    }

3、 捕获异常的时候同样自定义

            } catch (StudentAgeException e) {
                String message = e.getMessage();
                System.out.println(message);
            }

4、优化代码，确保所有能修改数据的地方都进行异常处理，否则数据都会出问题

    public Student (String name, int age) throws StudentAgeException {
        this.name = name;
        setAge(age);
    }

• 这里我将构造器传参都进行了判断异常处理，然而这里我直接使用setAge方法的调用处理了这个问题！