【Java 进阶篇】【第二课】异常处理

概念

---

异常处理的存在是为了：

　   允许程序员跳过无法处理的问题，继续开发后续的工作，或根据异常做出更加聪明的处理方式。

 

Java中存在一类对象叫“异常对象”。

当异常情况发生时，就会暗战预先的设定，抛出（throw） 代表当前状况的对象；抛出其实就是一种特殊的返回方式，该线程会暂停，逐层退出调用，直到遇到异常处理器（Exception Handler）。

异常处理器可以捕捉(catch)的异常对象，然后根据对象来决定下一步是提醒用户、处理一次还是退出程序等等..

 

基本结构

---

异常处理器由 try, catch, finally(这个可以没有) 以及随后的程序块组成 ：

try 
{
  ...;
}

catch() 
{
  ...;
}

catch() 
{
  ...;
}

finally
 {
  ...;
}

异常处理器 监视try后面的程序块，catch的括号中需要有一个参数，用来代表索要捕捉的异常的类型。catch会捕捉相应的类型和它的派生类。

try所监视的程序库可能抛出不止一种类型的异常，所以一个异常处理器可以有多个catch模块。

finally后面的程序块，无论是否发生异常，都会被执行。

 

我们在try中放入可能出错，需要监视的程序，在catch中设计应对异常的方案。

 

简单例子

---

 1 public class two
 2 {
 3     public two() throws IOException 
 4     {
 5         BufferedReader br = new BufferedReader(new FileReader("file.txt"));
 6         try 
 7         {
 8             StringBuilder sb = new StringBuilder();
 9             String line = br.readLine();
10 
11             while (line != null) 
12             {
13                 sb.append(line);
14                 sb.append("\n");
15                 line = br.readLine();
16             }
17             String everything = sb.toString();
18         } 
19         catch (IOException e)
20         {
21             e.printStackTrace();
22             System.out.println("IO problem");
23         }
24         finally 
25         {
26             br.close();
27         }
28     }
29 }

第19行，如果我们捕捉到了这样异常的话（即IOException类对象的e），可以对该对象对象。比如调用对象的printStackTrace()，打印出当前栈的状况 。

 

无论是否有异常，程序最终会进入finally块中，清空文件描述符所占据的资源。

 

异常类Trowable

---

Java中的异常类都继承自Trowable类。一个Throwable类的对象都可以抛出(throw)。

Throwable对象可以分为两组。

一组是unchecked异常(图中橘黄色)，异常处理机制往往不用于这组异常：

       Error类通常是指Java的内部错误以及如资源耗尽的错误。当Error(及其衍生类)发生时，我们不能在编程层面上解决Error，所以应该直接退出程序。

       RuntimeException(及其衍生类)是Java程序自身造成的，也就是说，由于程序员在编程时犯错。

       RuntimeException完全可以通过修正Java程序避免。比如将一个类型的对象转换成没有继承关系的另一个类型，即ClassCastException。这类异常应该并且可以避免。

一组是checked异常：

       这些类是由编程与环境互动造成程序在运行时出错。

　　 比如读取文件时，由于文件本身有错误，发生IOException。再比如网络服务器临时更改URL指向，造成MalformedURLException。文件系统和网络服务器是在Java环境之外的，并不是程序员所能控制的。如果程序员可以预期异常，可以利用异常处理机制来制定应对预案。比如文件出问题时，提醒系统管理员。再比如在网络服务器出现问题时，提醒用户，并等待网络服务器恢复。

       异常处理机制主要是用于处理这样的异常。

 

异常处理例子

---

 1 public class two
 2 {
 3     public static void main(String[] args)
 4     {
 5         Battery aBattery = new Battery(2); 
 6         aBattery.useBattery(-2.5);
 7     }
 8 }
 9 
10 class Battery
11 {
12     private double power = 0.0; // percentage of battery
13     Battery(double p)
14     {
15         power = p;
16     }
17 
18     public boolean useBattery(double p)
19     {
20         try 
21         {
22             test(p);
23         } 
24         catch (Exception e) 
25         {
26             System.out.println("catch Exception");
27             System.out.println(e.getMessage());
28             p = 0.0;
29         }
30 
31         if (this.power >= p) 
32         {
33             this.power = this.power - p;
34             return true;
35         } 
36         else
37         {
38             this.power = 0.0;
39             return false;
40         }
41     }
42 
43     private void test(double p) throws Exception 
44     {
45         if (p < 0) {
46             Exception e = new Exception("p must be positive");
47             throw e;
48         }
49     }
50 }

运行结果为：

catch Exception
p must be positive

 

自定义异常类

---

在代码中加入自己的异常类。

一般都是继承来创建新的异常类。在继承时，我们往往需要重写构造方法。异常有两个构造方法，一个没有参数，一个有一个String参数：

class BatteryUsageException  extends Exception
{
    public BatteryUsageException()    {}
    public BatteryUsageException( String msg)
    {
        super(msg);
        System.out.println("this is BatteryUsageException");
    }
}

然后修改Battery类中test函数为：

private void test(double p) throws BatteryUsageException 
{
    if (p < 0) 
    {
        BatteryUsageException e = new BatteryUsageException("p must be positive");
        throw e;
    }
}

 

这样的话输出的内容就是：

this is BatteryUsageException
catch Exception
p must be positive

 

好啦，全部完啦

我再把源代码贴一次吧

 1 public class two
 2 {
 3     public static void main(String[] args)
 4     {
 5         Battery aBattery = new Battery(2); 
 6         aBattery.useBattery(-2.5);
 7     }
 8 }
 9 
10 class Battery
11 {
12     private double power = 0.0; // percentage of battery
13     Battery(double p)
14     {
15         power = p;
16     }
17 
18     public boolean useBattery(double p)
19     {
20         try 
21         {
22             test(p);
23         } 
24         catch (Exception e) 
25         {
26             System.out.println("catch Exception");
27             System.out.println(e.getMessage());
28             p = 0.0;
29         }
30 
31         if (this.power >= p) 
32         {
33             this.power = this.power - p;
34             return true;
35         } 
36         else
37         {
38             this.power = 0.0;
39             return false;
40         }
41     }
42 
43     private void test(double p) throws BatteryUsageException 
44     {
45         if (p < 0) 
46         {
47             BatteryUsageException e = new BatteryUsageException("p must be positive");
48             throw e;
49         }
50     }
51 }
52 
53 class BatteryUsageException  extends Exception
54 {
55     public BatteryUsageException()    {}
56     public BatteryUsageException( String msg)
57     {
58         super(msg);
59         System.out.println("this is BatteryUsageException");
60     }
61 }

View Code