【异常】alt+shift+z 异常快捷键


异常：不正常，我们在代码的时候出现的编译或者运行时的错误

异常的体系结构：
        Throwable（最顶层）
                Error:出现的不能够处理的严重问题
                Exception:可以处理的问题

【关键词】
        1.Throwable[丝揉歪波]
        2. Error[哎若] 出现的不能够处理的严重问题
        3.Exception[一颗C可性]可以处理的问题

        4.try...catch[踹....凯起]
        5.throws[丝揉丝]处理异常的一种方式,把异常抛出,由调用者来处理
        6.throw[丝柔]制造异常的方式

【异常的处理方式】
        1. 捕获处理
                try...catch语句
*
*                 try {
*                         有可能出现问题的代码;
*                 } catch(ArithmeticException ae) {
*                         处理异常;
*                 }
*
*                 try...catch的执行顺序：
*                 首先执行try语句
*                 如果发现异常，异常下面的代码不在执行，直接跳入catch语句中，catch语句结束后，整个try...catch结束
*                 如果没有发现异常，try语句执行结束后，try...catch直接结束， 不在执行catch语句
*
       

        2. 抛出去
                当我们不想处理异常，或者没有能力处理的时候，我们可以选择抛出异常，谁调用方法谁处理异常
                使用关键字throws在方法的声明出抛出异常

jvm处理异常的方式：
           如果出现异常我们没有处理，jvm会帮我们进行处理，他会把异常的类型，原因还有位置显示在命令行
           并且还终止了程序，异常后面的代码将不在执行



如何处理多个异常：
                可以使用多个try...catch语句
                  使用一个try和多个catch

多个catch之间的顺序：
                  多个catch之间可以有子父类
                  平级之间没有顺序关系
                  如果有子父类，父类异常必须放在后面


【给程序员自己看的异常】

e.printStackTrace();



【Throwable】[丝揉歪波]


Throwable的常用方法：
                String getMessage()  异常出现的原因
                System.out.println(e.getMessage());


                String toString() 类型和原因
                        System.out.println(e.toString());



                void printStackTrace() 类型原因和位置
                        e.printStackTrace();




【finally】的概述和应用场景[f哎诺尼]


finally:组合try...catch使用，用于释放资源等收尾工作，无论try...catch语句如何执行，finally的代码一定会执行

   格式:
   try {
           有可能出现问题的代码;

   } catch(异常对象) {
           处理异常;
   } finally {
           释放资源;
           清理垃圾;
   }


【异常的分类】

        运行时期异常:
                RuntimeException的子类就是运行时期异常，在编译时期可以自由选择处理或者不处理
                比如:System.out.println(2 / 0);
        编译时期异常:
                是Exception的子类，非RuntimeExcpetion的子类，在编译时期必须处理
                比如:FileWriter fw = new FileWriter("a.txt");



【自定义异常】
               
       
* 需求：写一个方法，接受考试成绩，如果考试成绩的范围在0-100之间则属于正常，否则属于异常
*
* throws:处理异常的一种方式，把异常抛出，由调用者来处理
* throw:制造异常的方式,并且结束方法
*
* 注意：如果抛出（throw）的是编译时期异常，必须在方法声明处抛出（throws）
*
* 如何自定义一个异常类呢？
*                 非常简单，写一个类去继承Exception或者RuntimeException，然后实现多个构造即可

案例:

        public static void checkScore(int score) throws Exception {
                if(score < 0 || score > 100) {
                        //throw new RuntimeException("考试成绩不符合要求");
                        //throw new Exception("考试成绩不符合要求");
                        throw new MyException("考试成绩不符合要求");
                }
               
                System.out.println("考试成绩符合要求");
        }


【★递归】



需求：求5的阶乘
* 5! = 5 * 4 * 3 * 2 * 1;  //120
* 5! = 5 * 4!;                                        //120
*                 4! = 4 * 3!;                        //24
*                         3! = 3 * 2!;                //6
*                                 2! = 2 * 1!;        //2
*                                         1! = 1;     //1
        n! = n * (n - 1)!
       
        递归：把大问题拆成很多小问题，然后再把小问题拆成更多的小问题，
                        当我们把更多小问题解决了，小问题也解决了
                                随着小问题的解决，大问题也随之解决了
        在方法本身不断的调用方法自己
       
        递归注意事项：
                        递归一定要有出口，内存溢出
                        递归次数不宜过多，内存溢出
举例:
        public void show(int n) {//5
                //出口
                if(n == 0) {
                        return;
                }
               
                show(n - 1);
        }




【斐波那契列数】

保持，加油哦~