黑马程序员——JAVA学习日志之异常

------- android培训、java培训、期待与您交流！ ----------

学习日志之异常

异常(异常的概述和分类)

  A:异常的概述

         异常就是Java程序在运行过程中出现的错误。异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。  

B:异常的分类

Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例。

         通过API查看Throwable

         Error

               是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题，服务器宕机,数据库崩溃等

         Exception

               是程序本身可以处理的异常。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

C:异常的继承体系

         Throwable

                Error 

                Exception

                       RuntimeException

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

 

 

JVM默认是如何处理异常的

         main函数收到这个问题时,有两种处理方式:

         a:自己将该问题处理,然后继续运行

         b:自己没有针对的处理方式,只有交给调用main的jvm来处理

         jvm有一个默认的异常处理机制,就将该异常进行处理.

         并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上,同时将程序停止运行

异常(try...catch的方式处理异常1)

  A:异常处理的两种方式

         a:try…catch…finally

                trycatch

                trycatch finally

                tryfinally

         b:throws

  try:用来检测异常

  catch：用来捕获异常

  finally：用来执行必须执行的语句。例如释放资源。

  B:try...catch处理异常的基本格式

         try…catch…finally

  安卓和J2EE在处理异常的区别：

  安卓：因为是客户端发开，所以通常都是将异常自己私下处理了，以确保APP的能够继续运行。但是这样，异常就会被埋没了，留下来隐患。

  J2EE:因为是服务端开发，一般都是底层开发，所以异常就不可私自处理掉而留下隐患。而是将问题向上抛出，以生成日志文件。

  C:案例演示

        try...catch的方式处理1个异常

<span style="font-size:14px;">
</span>

<span style="font-size:14px;">        try {
                   int x = 10,y = 0;
                     int c = x / y;
         }catch (Exception e) {
                   System.out.priintln(e);     
         }</span>

 

异常(try...catch的方式处理异常2)

  A:案例演示

         try...catch的方式处理多个异常

        

         try {
         <span style="white-space:pre">	</span>语句1；//发生异常A ，实际运行时，程序运行到这里就发生异常被捕获，所以下面的语句2语句3以及捕获它们的catch语句都不会执
         <span style="white-space:pre">	</span>       //<span style="font-family: Arial, Helvetica, sans-serif;">行了</span>

<span style="white-space:pre">		</span>语句2；//发生异常B
         <span style="white-space:pre">	</span>语句3；//发生异常 C
         }catch(ExceptionA) {
                   System.out.println("异常A");
         }catch(ExceptionB) {
                   System.out.println("异常B");
         }catch(ExceptionC) {
                   System.out.println("异常C");
         }

       发生异常A ，实际运行时，程序运行到这里就发生异常被捕获，所以下面的语句2语句3以及捕获它们的catch语句都不会执行了。

       所以try后面的catch，小的异常放在前面，大的异常放后面。因为根据多态原理，大的异常会接受左右子类的对象，从而将异常吃掉，就没法知道到底发生了具体什么异常了。

         JDK7以后处理多个异常的方式及注意事项

        

         try{
         <span style="white-space:pre">	</span>语句1；//发生异常A
         <span style="white-space:pre">	</span>语句2；//发生异常B
         }catch(ExceptionA | ExceptionB) {
                  
         }

 

 

异常(编译期异常和运行期异常的区别)

通常，Java的异常(包括Exception和Error)分为可查的异常（checkedexceptions）和不可查的异常（unchecked exceptions）。

 

可查异常（编译器要求必须处置的异常）：

         正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。

     除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

     不可查异常(编译器不要求强制处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。

不可查异常在编译的时候不会被发现，也就是编写代码的时候不需要抛出或处理，当程序执行的时候出现的话，程序直接停下来。

可查的异常就是在写代码的时候必须要处理或抛出的，如果不处理或抛出就会出现红色报警。

     Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

       运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

      运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
       非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常

 

异常(Throwable的几个常见方法)

  A:Throwable的几个常见方法

         a:getMessage()

                获取异常信息，返回字符串。

         b:toString()

                获取异常类名和异常信息，返回字符串。

         c:printStackTrace()

                获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

  B:案例演示

         Throwable的几个常见方法的基本使用

 

 

异常(throws的方式处理异常)

  A:throws的方式处理异常

         定义功能方法时，需要把出现的问题暴露出来让调用者去处理。

         那么就通过throws在方法上标识。

Throws抛出异常的规则：

1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

    2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

    3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

 

  B:案例演示

         void method（） throws ExceptionA {

                   if（true）

                            throws new ExceptionA()；

         }

 

异常(throw的概述以及和throws的区别)

  A:throw的概述

         在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

  B:案例演示   

         分别演示编译时异常对象和运行时异常对象的抛出

  C:throws和throw的区别

         a:throws

                用在方法声明后面，跟的是异常类名

                可以跟多个异常类名，用逗号隔开

                表示抛出异常，由该方法的调用者来处理

              PS:就是一个声明，告诉别人，自己可能有异常，注意下。

         b:throw

                用在方法体内，跟的是异常对象名

                只能抛出一个异常对象名

                表示抛出异常，由方法体内的语句处理

 

异常(finally关键字的特点及作用)

  A:finally的特点

         被finally控制的语句体一定会执行

         特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

  B:finally的作用

         用于释放资源，在IO流操作和数据库操作中会见到

  C:案例演示

         finally关键字的特点及作用

 

异常(finally关键字的面试题)

  A:面试题1

         final,finally和finalize的区别

  B:面试题2

         如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。

         当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

      

异常(自定义异常概述和基本使用)

  A:为什么需要自定义异常

         为了将异常的具体情况进一步细化。

  B:自定义异常概述

         继承自Exception

         继承自RuntimeException

 

异常(异常的注意事项及如何使用异常处理)

  A:异常注意事项

         a:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

         b:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

         c:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

  B:如何使用异常处理

         原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws

         区别:

                后续程序需要继续运行就try

                后续程序不需要继续运行就throws

             

         如果JDK没有提供对应的异常，需要自定义异常。