JAVA异常处理机制
摘要
除非你能解决（或必须要处理）这个异常，否则不要捕获它， 如果打算记录错误消息，那么别忘了把它再抛出去。 异常既代表一种错误，又可以代表一个消息。
为什么需要异常
Java中异常提供了一种识别及响应错误情况的一致性机制， 有效地异常处理能使程序更加健壮、易于调试。 异常之所以是一种强大的调试手段，在于其回答了以下三个问题：
- 什么出了错?
- 在哪出的错?
- 为什么出错?
在有效使用异常的情况下，异常类型回答了“什么”被抛出， 异常堆栈跟踪回答了“在哪“抛出， 异常信息回答了“为什么“会抛出。
Java异常处理机制为：抛出异常，捕捉异常
抛出异常：
当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统， 异常对象中包含了异常类型和异常出现时的程序状态等异常信息。 运行时系统负责寻找处置异常的代码并执行。
捕获异常：
在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。 潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。 当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。
运行时系统从发生异常的方法开始，依次回查调用栈中的方法， 直至找到含有合适异常处理器的方法并执行。
当运行时系统遍历调用栈而未找到合适的异常处理器， 则运行时系统终止。同时，意味着Java程序的终止。
运行时异常、错误或可查异常处理方式
由于运行时异常(RuntimeException)的不可查性， 为了更合理、更容易地实现应用程序， Java规定，运行时异常将由Java运行时系统自动抛出， 允许应用程序忽略运行时异常。
对于方法运行中可能出现的错误(Error)， 当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。 因为，大多数Error异常属于永远不能被允许发生的状况， 也属于合理的应用程序不该捕捉的异常。
对于所有的可查异常，Java规定： 一个方法必须捕捉，或者声明抛出方法之外。 也就是说，当一个方法选择不捕捉可查异常时， 它必须声明将抛出异常。
能够捕捉异常的方法，需要提供相符类型的异常处理器。 所捕捉的异常，可能是由于自身语句所引发并抛出的异常， 也可能是由某个调用的方法或者Java运行时系统抛出的异常。 也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。 简单地说，异常总是先被抛出，后被捕捉的。
Java异常的捕获和处理是一个不容易把握的事情， 如果处理不当，不但会让程序代码的可读性大大降低， 而且导致系统性能低下，甚至引发一些难以发现的错误。
异常处理关键字
Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。 下面将骤一介绍， 通过认识这五个关键字，掌握基本异常处理知识。
try-catch
在Java中，异常通过try-catch语句捕获。其一般语法形式为：
try {
// 被检测的代码
// 可能出现的代码
} catch (异常类名 变量){
// 异常的 处理方式
}
关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。 Java方法在运行过程中出现异常，则创建异常对象。 将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。 若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。
匹配的原则是：
如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类， 则认为生成的异常对象与catch块捕获的异常类型相匹配。
捕捉运行时系统自动抛出“除数为0”引发的ArithmeticException异常：
public class ExceptionDemo1 {
public static void main(String[] args) {
int a = 10;
int b = 0;
try {
int c=a/b;
}
catch (ArithmeticException e) {
System.out.println("算术异常，除数为0");
}
}
}
运行结果：
算术异常，除数为0
try-catch-finally
try-catch语句还可以包括第三部分，就是finally子句。 它表示无论是否出现异常，都应当执行的内容。 try-catch-finally语句的一般语法形式为：
try {
// 被检测的代码
// 可能出现的代码
} catch(异常类名 变量){
// 异常的 处理方式
} finally{
//必须要执行的代码
}
try 块：
用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：
用于处理try捕获到的异常。
finally 块：
无论是否捕获或处理异常，finally块里的语句都会被执行。 当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。 在以下4种特殊情况下，finally块不会被执行：
- 在finally语句块中发生了异常。
- 在前面的代码中用了System.exit()退出程序。
- 程序所在的线程死亡。
- 关闭CPU。
捕捉数组下标越界异常：
public class ExceptionDemo2 {
public static void main(String args[]) {
int[] a = new int[3];
try {
a[3] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界异常");
} finally {
System.out.println("最终始终要执行");
}
}
}
运行结果：
数组下标越界异常
最终始终要执行
try-catch-finally 规则
必须在try之后添加 catch 或 finally 块。 try 块后可同时接 catch 和finally 块，但至少有一个块。
必须遵循块顺序：若代码同时使用 catch 和finally 块， 则必须将 catch 块放在 try 块之后。
catch 块与相应的异常类的类型相关。
一个 try 块可能有多个 catch 块。 若如此，则执行第一个匹配块。 即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配， 如果异常对象为某个异常类型或其子类的实例， 就执行这个catch代码块， 不会再执行其他的 catch代码块
可嵌套 try-catch-finally 结构。
在 try-catch-finally 结构中，可重新抛出异常。
除了下列情况，总将执行 finally 做为结束：
- JVM 过早终止（调用 System.exit(int)）;
- 在 finally 块中抛出一个未处理的异常;
- 计算机断电、失火、或遭遇病毒攻击;
try、catch、finally语句块的执行顺序
当try没有捕获到异常时：try语句块中的语句逐一被执行， 程序将跳过catch语句块，执行finally语句块和其后的语句；
当try捕获到异常，catch语句块里没有处理此异常的情况： 当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时， 此异常将会抛给JVM处理，finally语句块里的语句还是会被执行， 但finally语句块后的语句不会被执行；
当try捕获到异常，catch语句块里有处理此异常的情况： 在try语句块中是按照顺序来执行的， 当执行到某一条语句出现异常时， 程序将跳到catch语句块，并与catch语句块逐一匹配; 找到与之对应的处理程序，其他的catch语句块将不会被执行; 而try语句块中，出现异常之后的语句也不会被执行， catch语句块执行完后， 执行finally语句块里的语句，最后执行finally语句块后的语句；
图示try、catch、finally语句块的执行顺序：
抛出异常
任何Java代码都可以抛出异常， 如：自己编写的代码、来自Java开发环境包中代码， 或者Java运行时系统。 无论是谁，都可以通过Java的throw语句抛出异常。 从方法中抛出的任何异常都必须使用throws子句。
抛出异常throw
Throw在方法内部，用来抛出一个Throwable类型的异常。 程序会在throw语句后立即终止，它后面的语句执行不到， 然后在包含它的所有try块中（可能在上层调用函数中） 从里向外寻找含有与其匹配的catch子句的try块。
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。 该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常，最终JVM会进行处理， 处理也很简单，就是打印异常消息和堆栈信息。 如果抛出的是Error或RuntimeException， 则该方法的调用者可选择处理该异常。
抛出数组下标越界异常：
public class ExceptionDemo3 {
public static void main(String args[]) {
int[] a = new int[3];
try {
a[3] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
throw new ArrayIndexOutOfBoundsException("数组 下标越界异常了");
}
}
}
运行结果：
Exception in thread "main"java.lang.ArrayIndexOutOfBoundsException:数组下标越界异常了
atExceptionDemo3.main(ExceptionDemo3.java:11)
throw只是抛出异常暂时不做处理，但是总有一个地方要处理异常。
throws 对异常的说明
如果一个方法可能会出现异常，但没有能力处理这种异常， 可以在方法声明处用throws子句来声明抛出异常。 throws语句用在方法定义时声明该方法要抛出的异常类型， 如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常， 但不推荐直接使用Exception
当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理， 而抛向调用该方法的方法，由他去处理。 如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。
Throws抛出异常的规则
如果是不可查异常（unchecked exception）， 即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常， 编译仍能顺利通过，但在运行时会被系统抛出。
必须声明方法可抛出的任何可查异常（checked exception）。 即如果一个方法可能出现受可查异常， 要么用try-catch语句捕获，要么用throws子句声明将它抛出， 否则会导致编译错误
仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。 当方法的调用者无力处理该异常的时候， 应该继续抛出，而不是囫囵吞枣。
调用方法必须遵循任何可查异常的处理和声明规则。 若覆盖一个方法，则不能声明与覆盖方法不同的异常。 声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。 除此之外，用户还可以自定义异常。 用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
- 创建自定义异常类。
- 在方法中通过throw关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理； 否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常， 继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常。
自定义的异常：
public class FuShuException extends Exception {
public FuShuException() {
super();
}
public FuShuException(String message) {
super(message);
}
}
public class ExceptionDemo {
public static void main(String[] args) {
int avg;
try {
avg = getAvg(50,60,-70,80);
} catch (FuShuException e) {
e.printStackTrace();
}
}
//计算成绩平均数
private static int getAvg(int...source)throws FuShuException {
int sum=0;
for (int i : source) {
if (i<0) {
throw new FuShuException("成绩错误:"+i);
}
sum=sum+i;
}
return sum/source.length;
}
}
运行结果
FuShuException:成绩错误:-70
at ExceptionDemo.getAvg(ExceptionDemo.java:19)
at ExceptionDemo.main(ExceptionDemo.java:8)
自定义异常携带数据、状态码
异常类定义
import lombok.Data;
@Data
public class TubidaRuntimeException extends RuntimeException {
/**
* 错误状态码
*/
private int code;
/**
* 错误结果
*/
private Object result;
public TubidaRuntimeException() {
super();
}
public TubidaRuntimeException(String message) {
super(message);
}
public TubidaRuntimeException(String message, Throwable cause) {
super(message, cause);
}
public TubidaRuntimeException(Throwable cause) {
super(cause);
}
protected TubidaRuntimeException(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
/**
* 途必达自定义异常
*
* @param code 错误码
* @param format 格式化字符串
* @param paras 参数
*/
public TubidaRuntimeException(int code, String format, Object... paras) {
super(String.format(format, paras));
this.result = null;
this.code = code;
}
/**
* 途必达自定义异常
*
* @param result 结果
* @param code 错误码
* @param format 格式化字符串
* @param paras 参数
*/
public TubidaRuntimeException(Object result, int code, String format, Object... paras) {
super(String.format(format, paras));
this.result = result;
this.code = code;
}
}
抛出异常
Object main = 1;
throw new TubidaRuntimeException(main, -100 , "该票已游玩");
处理异常
// 前台请求代码
try {
String reqJson = ""; // 前台请求字符串
String response = requestHandle(reqJson); // 这里会抛出异常
// 输出请求结果
this.responseString(response);
} catch (TubidaRuntimeException ex) {
this.responseError(ex.getCode(), ex.getMessage(), ex.getResult());
} catch (InvocationTargetException ex) {
this.WriteException(ex.getTargetException());
} catch (Exception ex) {
this.WriteException(ex);
}
private void WriteException(Throwable ex) throws Exception {
ex.printStackTrace();
String msg = ex.getMessage();
if (StringHelper.IsEmpty(msg)) {
msg = ex.getClass().getName();
}
this.responseError(0, msg, null);
}
private void responseError(int status, String msg, Object result){
HashMap<String, Object> ret = new HashMap<String, Object>();
ret.put("status", status);
ret.put("msg", msg);
ret.put("result", result);
this.responseObject(ret);
}
private void responseObject(Object obj) throws Exception {
String json = JSONHelper.SerializeObject(obj);
responseString(json);
}
private void responseString(String str) throws Exception {
// 将字符串输出到前台
}
扫一扫
257
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
