首页 > > 程序设计 > Java技术 >

java中级异常篇

2018-06-18 03:50:08来源：未知阅读 ()

一.异常

1.异常的概述

什么是异常：是程序运行过程中发生未知的事件, 该事件可以中断程序指令的正常执行流程.

java中异常类的视图：

说明：Error和Exception的子类可以分为上图中的几类，并非所有子类。

Throwable：

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 throw语句抛出。

Error：

Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。它是程序无法处理的异常，一般与程序员的执行操作无关。理论上这些错误是不允许发生的，如果发生，也不应该试图通过程序去处理，所以Error不是try-catch的处理对象，而JVM一般的处理方式是终止发生错误的线程。Error类常见子类有VirtualMachineError与AWTError。

Exception：

Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。出现原因取决于程序，所以程序应通过try-catch处理。
异常分为两类：可查异常（编译时异常）与不可查异常（运行时异常）。

可查异常：

编译器要求必须处理，否则不能通过编译，使用try-catch捕获或者throws抛出。常见的可查异常有IOException（IO错误）及其子类EOFExcption(文件已结束异常)、FileNotFound（文件未找到异常）。

不可查异常：

编译期不会检查，所以在程序中可不处理，但如果发生，会在运行时抛出。所以这类异常要尽量避免！常见的不可查异常都是RuntimeException类及其子类。

2.声明异常：

通过throw关键字声明

 1 package com.wx.throwable;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 
 5 /**
 6  * @className 测试异常类
 7  */
 8 public class Test {
 9     public static void main(String[] args) throws FileNotFoundException,IOException {
10         try {
11             throw new Exception("这是声明的异常");
12         } catch (Exception e) {
13             e.printStackTrace();
14         }
15     }
16     
17 }

3.异常的处理：try catch finally 或者 throws

捕获异常（try catch finally）：

下面几种情况发生将不会执行finally中的代码：

1）在finally语句块中抛出了异常且未处理。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）CPU出现异常被关闭。

处理异常的示例：

 1 package com.wx.throwable;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.FileNotFoundException;
 6 import java.io.IOException;
 7 
 8 public class Test {
 9     public static void main(String[] args) {
10         FileInputStream fis=null;
11         try {
12             //可能出现异常的代码
13             fis=new FileInputStream("D:/abc.txt");
14         } 
15         catch (FileNotFoundException e) {
16             //处理异常
17             e.printStackTrace();
18         }
19         finally{
20                 if (fis!=null) {
21                     try {
22                         //释放资源
23                         fis.close();
24                     } catch (IOException e) {
25                         e.printStackTrace();
26                     }
27                 }
28         }
29     }
30 }

try-catch-finally处理异常

从上面的示例中可以看到，try-catch-finally语句可以嵌套的。

throws：

通过往外抛的方式处理异常，让下次的调用者去处理异常，如果一直往外抛，即main方法也往外抛，就会交给程序处理。这样的方式只会过滤掉编译时异常，由于最终都没有处理，所以一旦出现异常，程序就会中断。

throws处理异常的示例：

 1 package com.wx.throwable;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileNotFoundException;
 5 import java.io.IOException;
 6 
 7 public class Test {
 8     public static void main(String[] args) throws FileNotFoundException,IOException {
 9         FileInputStream fis=new FileInputStream("D:/abc.txt");
10         if (fis!=null) {
11                 fis.close();
12         }
13     }
14 }

throw处理异常

4.自定义异常

创建自定义异常类MyException继承Exception：

 1 package com.wx.throwable;
 2 
 3 public class MyException extends Exception {
 4     
 5     public MyException() {
 6         
 7     }
 8     public MyException(String msg) {
 9         super(msg);
10     }
11 }

使用异常：

 1 package com.wx.throwable;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 
 5 /**
 6  * @className 测试异常类
 7  */
 8 public class Test {
 9     public static void main(String[] args) throws FileNotFoundException,IOException {
10         try {
11             new Test().throwMyException();
12         } catch (MyException e) {
13             e.printStackTrace();
14         }
15     }
16     
17     /**
18      * 抛出自定义异常
19      * @throws MyException
20      */
21     public void throwMyException() throws MyException {//往外抛
22         throw new MyException("出错了");//抛出异常
23     }
24     
25 }