目录

• 1、递归的介绍和使用
• • 1.1 递归的介绍
  • 1.2 案例
  • • `案例一：`
    • `案例二：`
    • `案例三：`
    • `案例四：`
  • 1.3 总结
• 2、`异常的介绍和使用`
• • 2.1 异常的介绍：
  • • （1）能够看懂异常
    • （2）异常的体系接口和分类
    • （3）总结
  • 2.2 异常的处理方式
  • • `（1）异常的默认处理流程`
    • `（2）异常处理方式 try...catch和throw抛出`
    • `（3）总结`
  • 2.3 自定义异常
  • 2.4 练习

1、递归的介绍和使用

1.1 递归的介绍

package com.itheima.recursion;

/**
 * Title: RecurisonDemo1
 * Describe: 类的功能
 * Name: masizhou
 * Date: 2024/7/11
 * Copyright: @2022 by masizhou
 */

public class RecurisonDemo1 {
    /**
     * 递归介绍：方法直接或间接地调用本身
     */
    public static void main(String[] args) {
        methodA();
    }

    public static void methodA(){
        methodB();
    }

    public static void methodB(){
        methodC();
    }

    public static void methodC(){
        methodA();
    }
}

上述方法会发生栈内存溢出异常，如下：

1.2 案例

案例一：

package com.itheima.recursion;

public class RecurisonDemo2 {
    public static void main(String[] args) {
        /**
         * 需求：使用递归求5的阶乘
         */
        int result = jc(5);
        System.out.println("5的阶乘是：" + result);//5的阶乘是：120

    }

    public static int jc(int num){
        if (num == 1){
            return 1;
        }
        return jc(num - 1) * num;
    }
}

栈内存图分分析：

案例二：

package com.itheima.recursion;

public class RecurisonDemo3 {
    public static void main(String[] args) {
        /**
         * 需求：使用递归求1~n之和
         */
        int result = sum(100);
        System.out.println(result);//5050
    }

    public static int sum(int num){
        if (num == 1){
            return 1;
        }

        return num + sum(num - 1);
    }
}

案例三：

package com.itheima.recursion;

public class RecurisonDemo4 {
    public static void main(String[] args) {
        /**
         * 需求：使用递归实现斐波那契数列：1 1 2 3 5 8 13 21...
         */
        int result = f(20);
        System.out.println(result);//6765
    }

    public static int f(int num){
        if (num <= 2){
            return 1;
        }

        return f(num - 1) + f(num - 2);
    }
}

案例四：

package com.itheima.recursion;

public class RecursionDemo5 {
    public static void main(String[] args) {
        /**
         * 需求：猴子吃桃 (n / 2) - 1
         */
        int result = eat(1);
        System.out.println(result);//1534
    }

    public static int eat(int day){
        if (day == 10){
            return 1;
        }

        // 今天的桃子数 = (明天桃子数+1) * 2
        return 2 * (eat(day + 1) + 1);
    }
}

1.3 总结

2、异常的介绍和使用

2.1 异常的介绍：

（1）能够看懂异常

package com.itheima.expection;

public class ExceptionDemo1 {
    /**
     * 阅读异常信息：从下往上
     *          1、找异常错误位置
     *          2、异常名称
     *          3、异常原因
     */
    public static void main(String[] args) {
        mothed();
    }
    public static void mothed(){
        int[] arr = {1, 2, 3};
        System.out.println(arr[10]);
    }
}

上述代码会抛出异常，异常信息如下：

在阅读异常时，遵循从下往上的原则：
- 1、找异常错误位置
- 2、异常名称
- 3、异常原因

注：要是遇到不认识的异常怎么办呢？
答：所有的异常都是类，因此把这个类复制下来，到Java的API文档去看详细信息即可。

（2）异常的体系接口和分类

package com.itheima.expection;

import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.FileHandler;

public class ExceptionDemo2 {
    public static void main(String[] args) throws ParseException, IOException {
        /**
         * - 编译时异常：编译阶段就出现的异常（语法错误不算）。需要在运行之前给出解决方案。
         * - 运行时异常：编译过了，运行期间【可能会出现的异常】
         */
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd");
        Date parse = simpleDateFormat.parse("2008年12月12日");//编译异常，需要给出解决方案

        FileHandler f = new FileHandler("D:\\a.txt");//编译异常，需要给出解决方案
    }
}

（3）总结

2.2 异常的处理方式

（1）异常的默认处理流程

（2）异常处理方式 try...catch和throw抛出

package com.itheima.expection.handle;
public class HandleDemo1 {
    /**
     * 异常的处理方式：
     * 1、try...catch捕获异常
     *      好处：   异常对象可以被捕获，后续的代码可以继续执行
     *      格式：
     *              try{
     *                  可能会出现异常的代码
     *              } catch(异常名称 对象名){
     *                  异常的处理方案
     *              }
     *      执行流程：
     *              1、执行try{}中的代码，看是否有异常对象
     *              2、没有：catch就不会捕获，后续代码继续执行
     *              3、有：catch捕获异常对象，执行catch{}中的处理方案，后续代码继续执行
     * 2、throw 抛出异常
     *
     *
     * ----------------------------------------------------------------------------
     *
     * 问题：正在面临的异常，是否需要暴露出来
     *      - 不需要暴露：try...catch捕获
     *      - 需要暴露：抛出异常
     */
    public static void main(String[] args) {
        //1、try...catch捕获异常
        System.out.println("开始");
        try {
            System.out.println(10/0);  // new ArithmeticException();
        }catch (ArithmeticException e){
            System.out.println("捕获了运算异常");
        }

        System.out.println("结束");
    }
}

（3）总结

2.3 自定义异常

package com.itheima.expection.handle;

/**
 * 自定义运行异常
 */

public class MyException extends RuntimeException{
    public MyException() {
    }

    public MyException(String message) {
        super(message);
    }
}

package com.itheima.expection.handle;

import java.util.Scanner;

public class HandleDemo2 {
    /**
     * 使用自定义异常
     *
     */
    public static void main(String[] args) {
        try {
            myFunction();//此方法会抛出自定义的异常
        } catch (MyException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void myFunction(){
        throw new MyException("我的自定义异常");
    }
}

2.4 练习