java_异常体系（一）

1. 异常的继承体系

注意：Throwable 类是 Java 语言中所有Error或Exception的超类。

Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

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

Throwable类中常用方法如下：

1. 返回异常发生时的详细信息
public string getMessage();

2. 返回异常发生时的简要描述
public string toString();

3. 返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。

如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同

public string getLocalizedMessage();

4. 在控制台上打印Throwable对象封装的异常信息
public void printStackTrace();

2.Error

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

例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。

这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。

3.Exception

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

1.运行时异常：

都是RuntimeException类及其子类异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

 

 2.编译时异常：

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

4.异常处理

1.try...catch关键字

使用 try 和 catch 关键字可以捕获异常。

try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

 try {
  　 // 程序代码
　} catch (ExceptionName e1) {
　   //Catch 块
　}

catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：

try{
   // 程序代码
} catch (异常类型1 异常的变量名1) {
  // 程序代码
} catch (异常类型2 异常的变量名2) {
  // 程序代码
} catch (异常类型2 异常的变量名2) {
  // 程序代码
}

2.throws/throw 关键字

如果一个方法没有捕获一个检查性异常，那么该方法必须使用 throws 关键字来声明。

throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

下面方法的声明抛出一个 RemoteException 异常：

public class className {
  public void deposit(double amount) throws RemoteException {
    // Method implementation
    throw new RemoteException();
  }
}

 一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。 

3.finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下

try {
  // 程序代码
} catch (异常类型1 异常的变量名1) {
  // 程序代码
} catch (异常类型2 异常的变量名2) {
  // 程序代码
} finally {
  // 程序代码
}

4.try-catch-finally 的执行顺序

public class Demo1 {
    public static int test1(){
        int i = 1;
        try {
            i++;
            System.out.println("try block, i = "+i);
        } catch (Exception e) {
            i--;
            System.out.println("catch block i = "+i);
        } finally {
            i = 10;
            System.out.println("finally block i = "+i);
        }
        return i;
    }
    public static void main(String[] args){
        int result = test1();
        System.out.println(result);
    }
}

运行结果：

　　try block, i = 2
　　finally block i = 10
　　10

 

public class Demo2 {
    public static int test2(){
        int i = 1;
        try {
            i++;
            throw new Exception();
        } catch (Exception e) {
            i--;
            System.out.println("catch block i = " + i);
        } finally {
            i = 10;
            System.out.println("finally block i = " + i);
        }
        return i;
    }
    public static void main(String[] args){
        int result = test2();
        System.out.println(result);
    }
}

运行结果：

　　catch block i = 1
　　finally block i = 10
　　10

 

public class Demo3 {
    public static int test3(){
        //try 语句块中有 return 语句时的整体执行顺序
        int i = 1;
        try{
            i++;
            System.out.println("try block, i = " + i);
            return i;
        } catch (Exception e) {
            i ++;
            System.out.println("catch block i = " + i);
            return i;
        } finally {
            i = 10;
            System.out.println("finally block i = " + i);
        }
    }
    public static void main(String[] args){
        int result = test3();
        System.out.println(result);
    }
}

运行结果：

　　try block, i = 2
　　finally block i = 10
　　2

 

public class Demo4 {
    public static int test4(){
        //finally 语句块中有 return 语句
        int i = 1;
        try {
            i++;
            System.out.println("try block, i = " + i);
            return i;
        } catch (Exception e) {
            i++;
            System.out.println("catch block i = " + i);
            return i;
        } finally {
            i++;
            System.out.println("finally block i = " + i);
            return i;
        }
    }
    public static void main(String[] args){
        int result = test4();
        System.out.println(result);
    }
}

运行结果：

　　try block, i = 2
　　finally block i = 3
　　3