java入门之异常处理小结

（1）异常和错误

异常（Exception）：不正常的事件,会中断程序，在运行中发生的意外,程序本身可以处理,防止程序中断；程序中会捕获的异常信息，并告诫用程序员,不要求程序必须对它做处理.catch完之后不作处理.

错误（Error）：程序本身无法处理的.比如跟操作系统不兼容的问题.设计内存问题.,应用程序不应该抛出这类异常信息，这种错误程序员无法处理。

（2）异常的分类;

下图表示了异常类之间的关系.

aaarticlea/png;base64,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" alt="" width="485" height="299" />

所有的异常类的父类都是Exception,它有两大分支：检查异常类和非检查异常类(RuntimeException)，

又称是编译器异常）和运行期异常（比如）。

编译器异常就是在编译器中敲代码时候的错误提示,如果不修改就没法运行这个程序。

运行期异常顾名思义就是程序编译通过，但是在输出时候发生异常，比如是在控制台输入时敲错了数字,导致进行运算时候发生错误;如进行除法运算，输入了0；

Exception一个重要的分支是runtimeexception，它是描述编程产生的错误，这种异常通常由JVM自动捕获并抛出，说明这段代码有问题.下面就要说明捕获到异常之后怎么处理.

（3）异常的处理;

将意外进行处理的语句;

1.Try-catch语句；

try-catch的语法格式如下：

Try

{

//可能发生的异常代码

}

Catch

{

//捕捉到异常之后的对它的处理;

}

（示例代码如下）

 public class exceptiondemo {

     public static void main(String[] args) {

         int a=0;
         int b=0;
         try{

             System.out.println(a/b);

         }
         catch(Exception e)
         {

             e.printStackTrace();
             //获取异常的堆栈信息
             //可以自己定义捕捉异常之后输出的提示内容,让程序员更加明白发生了的什么异常；
             System.out.println("除法运算出现异常");

         }

         System.out.println("finish!");

     }
 }

try-catch语句的使用

运行结果；

除法运算出现异常

finish!

java.lang.ArithmeticException: / by zero

at day23_1027.exceptiondemo.main(exceptiondemo.java:11)

通过上面的代码以及运行结果发现：上面可以发现,catch捕捉到异常,但是并不会影响后面的语句执行，而如果没有用trycatch语句来获取异常信息,后面的代码并不会执行。

但是在程序中Try会抛出很多种类的异常(空指针,或者是数学运算的问题都有可能)，这个时候不建议只用一个Exception来捕获各种异常,当有多个try catch语句的时候,程序会按顺序执行，这个时候父类异常Exception应该放在后面,子类的错误放在前面,当抛出的异常都不属于子类的异常,就由父类来捕获处理.就是说先小后大,先子类后父类.

public static void main(String[] args) {

        int a=2;
        int b=1;
        String c=null;
        try{

            System.out.println("a/b="+a/b);
            int index=c.indexOf(0);
            System.out.println(index);
        }
        catch(ArithmeticException e)
        {

            System.out.println("除数不能为0！！");
        }
        catch(NullPointerException e)
        {

            System.out.println("检测到空指针异常！！");

        }
        catch(Exception e)
        {
            System.out.println("检测到不知名异常！！");
        }

        System.out.println("风雨不改还是运行完了");

    }
}

多catch的使用

运行结果：

a/b=2

检测到空指针异常！！

风雨不改还是运行完了

当父类异常放在前面的时候,会有如下显示,可见在编译器中两个子类都有错误提示出现.（可在编译器中复制错误代码示例看编译器报错的提示）

一般一段代码可能有多种异常抛出时,不要把父类的异常放在前面。

ry{

System.out.println("a/b="+a/b);

int index=c.indexOf(0);

System.out.println(index);

}

catch(Exception e)

{

System.out.println("检测到不知名异常！！");

}

catch(ArithmeticException e)

{

System.out.println("除数不能为0！！");

}

catch(NullPointerException e)

{

System.out.println("检测到空指针异常！！");

}

错误代码示例

最后提示一点：

一个catch只会处理一个try的信息,不可一个try同时匹配到多个catch信息.（放在同一个try里面,不能同时检测到空指针同时又检测到除数不能为0）,不同功能的代码就放在不同的try里面.

(2)Try-catch-finally 语句

在java中,Finally的作用是程序不管什么情况都会执行里面的代码,不管是否执行catch语句;对于大多数程序都是这样子。

但是也有唯一的情况————————

System.exit(1)   //该语句意思是直接退出JAVA虚拟机

若程序中出现该语句,并且在finally语句之前,那么finally不会执行,这也是finally不执行的唯一情况;

下面通过实例来演示finally的作用：

 public class exceptiondemo2 {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int a=1;
        int b=0;
        String c=null;
        try{

            System.out.println("a/b="+a/b);
            int index=c.indexOf(0);
            System.out.println(index);
        }
        catch(ArithmeticException e)
        {

            System.out.println("除数不能为0！！");
        }
        finally{

            System.out.println("(这是finally语句块)这是一定要执行的！！");

        }
        System.out.println("程序执行完了！！");

    }

}

finally的使用

（3）try-catch-finally 语句若try中&catch有returns的情况

完整try-catch-finally 若try中&catch有returns语句且先不将此返回给调用者，等finally执行完毕后返回return。

try...catch...finally...三个语句块中如果有return语句的执行顺序。

finally中有return用finally.return代替，顺序为：

“try语句 -> catch -> finally -> finally.return -> catch.return -> try.return”任何阶段的return被执行，则整个语句块结束。

二：小总结

（1）异常处理的流程：

try { //执行的代码，其中可能有异常。一旦发现异常，则立即跳到catch执行。否则不会执行catch里面的内容 }

catch { //除非try里面执行代码发生了异常，否则这里的代码不会执行 }

finally { //不管什么情况都会执行，包括try catch 里面用了return ,可以理解为只要执行了try或者catch，就一定会执行 finally }

所以通常都会用finally语句来进行资源的释放；比如涉及到数据库的使用好关闭,出现了异常立马关闭数据库.

（2）try-catch实际应用

对于不确定的代码,可以加上try-catch处理潜在的异常;

尽量去处理异常,最好不要只是简单的调用printStackTrace()去打印输出; 比如是在打印输出异常同时最好加点操作,比如是业务回滚;

具体怎么去处理异常，就要根据不同的业务需求和异常类型去决定,

有网络连接和连接数据库的历程，尽量去添加finally语句去释放占用的资源,在程序发生异常或者执行结束之后自动清理内存资源，减少系统负担。