Java- 异常的抛出与捕获

异常的基本概念

• 异常（exception）又称为例外、差错、违例
• 对应着Java运行错误处理机制

• 基本写法：

      try{
          ...
      }catch(Exception ex){
          异常处理语句组
      }

import java.io.*;
public class ExceptionForNum 
{
    public static void main(String[] args) 
    {
        try{
            BufferedReader in = new BufferedReader(
                new InputStreamReader( System.in ) );
            System.out.print("Please input a number: ");
            String s = in.readLine();
            int n = Integer.parseInt( s );
        }catch(IOException ex){
            ex.printStackTrace();
        }catch(NumberFormatException ex){
            ex.printStackTrace();
        }
    }
}
-----------OUTPUT-----------  
Please input a number: java.lang.NumberFormatException: null
    at java.lang.Integer.parseInt(Integer.java:542)
    at java.lang.Integer.parseInt(Integer.java:615)
    at ExceptionForNum.main(ExceptionForNum.java:11)

传统的语言如何处理异常

• 在一些传统的语言（如C语言中）
  
  • 使用各种if语句来判断是否出现例外
  • 全程变量ErrNo来记录错误的代码
• 但这有几点缺点
  
  1. 正常处理与异常处理的代码同样处理
     
     • 可读性（readability）差
  2. 每次调用一个方法时都进行差错检查
     
     • 可维护性（maintainability）差
  3. 错误由谁处理不清
     
     • 职责不清

Java中的异常处理

• Java中异常处理的流程

  1. 抛出（throw）异常，throw异常对象
  2. 运行时系统在调用栈中查找异常
     
     • 从生成异常的方法开始进行回溯，直到找到，即哪个地方找到catch语句

  3. 捕获（catch）异常的代码

     try{
         ...
     }catch(异常类名 异常形参名){
         异常处理语句组
     }catch(异常类名 异常形参名){
         异常处理语句组
     }finally{
         异常处理语句组
     }

     其中，catch语句可以0个至多个，可以没有finally语句
     

• Java异常处理要点：
  
  1. 程序执行完 try 里面的代码块之后，如果在不抛出异常的情况下，该异常处理并不会立即结束，而是继续试图去寻找有没有 finally 的代码块
  2. 如果没有 finally 代码块，整个方法在执行完 try 代码块后返回相应的值来结束整个处理过程；
  3. 如果有 finally 代码块，则执行到 try 代码块里的 return 语句时并不会立即执行 return，而是先去执行 finally 代码块里的代码
  4. 如果 finally 代码块里没有 return 语句且没有能够终止程序的代码，程序将在执行完 finally 代码块之后再返回 try 代码块执行 return 语句来结束整个处理流程
  5. 如果 finally 代码块里有 return 或含有能够终止程序的代码，处理流程将在执行完 finally 之后被结束，不再跳回 try 代码块执行 return
  6. 若异常处理中有抛出异常的情况下，原理也是和上面的一样的，只需把上述中的说到的 try 换成 catch 去理解就 OK 了

异常的分类

• Throwable
  
  • Error：JVM的错误
  • Exception：异常
• 一般说的异常是指Exception及其子类
  

Exception类

• 构造方法
  
  • public Exception();
  • public Exception(String message);
  • Exception(String message, Throwable cause);
• 方法
  
  • getMessage()
  • getCause()
  • printStackTrace()// 调用堆栈的跟踪信息

多异常的处理

• 子类异常要排在父类异常的前面
• finally语句
  
  • 无论是否有异常都要执行
  • 即使其中有break，return语句
  • 在编译时，finally部分代码生成了多遍

public class TestTryFinally {
    public static String output = "";

    public static void foo(int i) {
        try {
            if (i == 1) {
                throw new Exception();  // throw an exception
            }
            output += "1";
        } catch(Exception e) {  // catch the exception
            output += "2";
            return;
        } finally {     // must be executed
            output += "3";
        }
        output += "4";
    }

    public static void main(String args[]) {
        System.out.println("======== foo(0) =========");
        foo(0);
        System.out.println(output + " ");
        output = "";

        System.out.println("======== foo(1) =========");
        foo(1);
        System.out.println(output);
    }
}
-----------OUTPUT-----------  
======== foo(0) =========
134 
======== foo(1) =========
23