异常学习笔记

   1)程序运行过程中的对不正常现象描述后的对象体现就叫异常。

   2)导致程序运行不正常的现象有很多，所以，就有很多的异常对象。

       而这些异常对象存在着共性的内容，所以，可以不断的进行抽取。最终形成了异常的体系结构。
       异常体系的根类是:Throwable
       Throwable：
        |--Error:重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
        |--Exception:一般性的错误，是需要我们编写代码进行处理的。
            |--RuntimeException:运行时异常，这个我们也不需要处理。
                                其实就是为了让他在运行时出问题，然后我们回来修改代码。
    3)异常的分类        
        异常有两种：
        编译时被检测异常：
            该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
            该异常被标识，代表这可以被处理。
        运行时异常(编译时不检测)RuntimeException
            在编译时，不需要处理，编译器不检查。
            该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
    4)异常体系的特点：
        异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。
   5)main方法是如何处理异常的。
        A:在main里面编写代码进行处理
        B:交给jvm自己进行处理。采用的是jvm的默认处理方式。
          其实就是相当于调用了异常对象的printStackTrace()方法。
     6)Throwable类的学习
        getMessage():获取异常信息，返回字符串。
        toString():获取异常类名和异常信息，返回字符串。
        printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
    7)异常的处理·
        A:try...catch...finally
        基本格式：
            try
            {
                可能出现异常的代码
            }
            catch(异常对象)
            {    
                异常处理代码
            }
            finally
            {
                释放资源
            }
        
        其他格式：
            try...catch
            try...catch...catch...
            try...catch...catch...finally
        **多个异常同时被捕获的时候，记住一个原则：
            先逮小的，再逮大的。
        **finally:永远被执行， 除非退出jvm。System.exit(0);
            面试题2个。
            ***：final,finally,finalize区别。
               final是最终的意思。它可以用于修饰类，成员变量，成员方法。
               它修饰的类不能被继承，它修饰的变量时常量，它修饰的方法不能被重写。

               finally:是异常处理里面的关键字。
               它其中的代码永远被执行。特殊情况：在执行它之前jvm退出。System.exit(0);

               finalize:是Object类中的一个方法。
               它是于垃圾回收器调用的方式。

            ***：假如catch中有return语句， finally里中的代码会执行吗？
               是在return前，还是在return后呢？
               会，在return前执行finally里面的代码。
    (8)Exception和RuntimeException的区别
        A:Exception:一般性的错误，是需要我们编写代码进行处理的。    
        B:RuntimeException:运行时异常，这个我们也不需要处理。
                       其实就是为了让他在运行时出问题，然后我们回来修改代码。
            在用throws抛出一个的时候，如果这个异常是属于RuntimeException的体系的时候，
            我们在调用的地方可以不用处理。(RuntimeException和RuntimeException的子类)
            
            在用throws抛出一个的时候，如果这个异常是属于Exception的体系的时候，
            我们在调用的地方必须进行处理或者继续抛出。
   9)自定义异常
        定义类继承Exception或者RuntimeException
        1,为了让该自定义类具备可抛性。
        2，让该类具备操作异常的共性方法。
        class MyExcepiton extends Exception
        {
            MyExcepiton(){}

            MyExcepiton(String message)
            {
                super(message);
            }
        }

        class MyException extends RuntimeException
        {
            MyExcepiton(){}

            MyExcepiton(String message)
            {
                super(message);
            }
        }
   10)throws和throw的区别
        A：有throws的时候可以没有throw。
           有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
        B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开

           throw用于方法体中，其后跟的是一个异常对象名

   11)异常在子父类覆盖中的体现：

         A：子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类异常或者该异常的的子类。如果父类抛出多个异常，那么子类在覆盖方法时，只能抛出父类异常的子集。

        B：如果父类或者接口的方法中没有异常抛出，那么子类覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须进行try处理，绝对不可以抛。

   12)异常的好处

         A：将异常封装

         B：将正常流程代码和问题处理代码相分离，方便阅读。