【JavaSE】异常

Java异常

2019-07-06 22:16:29 by冲冲

1. 引例

任何程序都有出错的可能。比如代码少一个分号，那么运行的结果是 java.lang.Error。比如运行 System.out.println(11/0)，那么程序会抛出java.lang.ArithmeticException 的异常。

Java异常是一个对象。异常既代表一种错误，也代表一个消息，一个需要操作者回应如何解决问题的信息。

2. 异常的类型

（1）Throwable 类是 Error 类和 Throwable 类的父类。

① Error类：Error类发生在运行时。Java 程序通常不捕获错误，它们在Java程序处理的范畴之外。例如，JVM 内存溢出。程序不会从错误中恢复，程序会终止。

② Exception类：所有的异常类都是继承 java.lang.Exception 类的子类。异常类有两个主要的子类：IOException 类和 RuntimeException 类。程序本身可以捕获异常，并且处理异常。

异常和错误的区别：异常是可以被处理的，而错误是没法处理的。

（2）异常的类型

① 检查性异常: 不处理，则编译不能通过。

② 非检查性异常: 不处理，但是编译可以通过，如果有抛出直接抛到控制台。

③ 运行时异常: 就是非检查性异常。

④ 非运行时异常: 就是检查性异常。

3. 异常的处理

Java 的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。

try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。

（1）try-catch

 1 try {
 2 
 3      //可能产生异常的代码区，也称为监控区
 4 
 5    } catch(ExceptionType1 e) {
 6 
 7      //捕获并处理try抛出异常类型为ExceptionType1的异常
 8 
 9    } catch(ExceptionType2 e) {
10 
11      //捕获并处理try抛出异常类型为ExceptionType2的异常
12 
13    }

执行流程：

① try块（监控区）一旦发生异常，则会根据当前运行时的信息创建异常对象，并将该异常对象抛出监控区。

② 系统根据该异常对象依次匹配catch子句，若匹配成功（抛出的异常对象的类型和catch子句的异常类的类型或者是该异常类的子类的类型一致），则运行其中catch代码块中的异常处理代码，一旦处理结束，那就意味着整个try-catch结束。

③ 含有多个catch子句，一旦其中一个catch子句与抛出的异常对象类型一致时，其他catch子句将不再有匹配异常对象的机会。

 1 import java.io.*;
 2 public class ExcepTest{
 3    public static void main(String args[]){
 4       try{
 5          int a[] = new int[2];
 6          System.out.println("Access element three :" + a[3]);
 7       }catch(ArrayIndexOutOfBoundsException e){
 8          System.out.println("Exception thrown  :" + e);
 9       }
10       System.out.println("try-catch块后面的代码...");
11    }
12 }

输出结果：

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
try-catch块后面的代码...

多重try-catch

 1 try {
 2     file = new FileInputStream(fileName);
 3     x = (byte) file.read();
 4 } catch(FileNotFoundException f) { // Not valid!
 5     f.printStackTrace();
 6     return -1;
 7 } catch(IOException i) {
 8     i.printStackTrace();
 9     return -1;
10 }

（2）try-catch-finally

 1 try {
 2 
 3        //可能产生的异常的代码区
 4 
 5    }catch (ExceptionType1 e) {
 6 
 7        //捕获并处理try抛出异常类型为ExceptionType1的异常
 8 
 9    }catch (ExceptionType2 e){
10 
11        //捕获并处理try抛出异常类型为ExceptionType2的异常
12 
13    }finally{
14 
15        //无论是否出现异常，finally块中的代码都将被执行
16 
17    }

执行流程：

① try没有产生异常时，try代码块中的语句依次被执行。try块执行完毕，跳过catch。如果存在finally，则执行finally代码块，否则执行后续代码。

② try产生到异常时，如果没有与之匹配的catch子句，则该异常交给JVM处理。如果存在finally，则其中的代码仍然被执行，但是finally之后的代码不会被执行。

③ try产生到异常时，如果存在与之匹配的catch，则跳到该catch代码块执行处理。如果存在finally，则执行finally代码块，执行完finally代码块之后继续执行后续代码；否则直接执行后续代码。

④ try产生异常，则try块剩余代码不执行。

注意：

① catch 不能独立于 try 存在。

② 在 try/catch 后面添加 finally 块并非强制性要求的。

③ try 代码后不能既没 catch 块也没 finally 块。

④ try, catch, finally 块之间不能添加任何代码。

（3）finally

finally代码块：无论是否捕获异常，finally代码总会被执行。如果try代码块或者catch代码块中有return语句时，finally代码块将在方法返回前被执行。

finally代码块不会被执行的三种情况：

① 在前边的代码中使用System.exit()退出应用。

② 程序所在的线程死亡或者CPU关闭。

③ 如果在finally代码块中的操作又产生异常，则该finally代码块不能完全执行结束，同时该异常会覆盖前边抛出的异常。

（4）抛出异常

方法中用try-catch/try-catch-finally语句捕获并处理异常。但是对于没能力处理的异常，需要通过throws/throw抛出，交给上层的调用方法处理。

① throws 关键字放在方法签名的尾部。一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

1 public class ExceptionTest
2 {
3    public void someMethed() throws RemoteException, InsufficientFundsException
4    {
5        // Method implementation
6    }
7    ...
8 }

② throw

throw应用再方法内，抛出一个Throwable类型的异常。一旦遇到throw语句，后面的代码都不被执行。如果有finally则执行完再抛出。

throw只能抛出Throwable类和其子类的对象。

public void someMethod() throws RemoteException
{
    // Method implementation
    throw new RemoteException();
}
  //...
}

1 try{
2 
3     //可能会发生异常的代码
4 
5 }catch(Exception e){
6 
7       throw e;
8 
9 }

参考：

https://www.runoob.com/java/java-exceptions.html

https://blog.csdn.net/michaelgo/article/details/82790253

https://blog.csdn.net/zhanaolu4821/article/details/81012382

try{file = newFileInputStream(fileName); x = (byte)file.read(); }catch(FileNotFoundExceptionf){// Not valid!f.printStackTrace(); return -1; }catch(IOExceptioni){i.printStackTrace(); return -1; }