【Java基础篇】Java异常篇
Java 异常
异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。
比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error
;如果你用System.out.println(11/0)
,那么你是因为你用0做了除数,会抛出 java.lang.ArithmeticException
的异常。
异常发生的原因有很多,通常包含以下几大类:
- 用户输入了非法数据。
- 要打开的文件不存在。
- 网络通信时连接中断,或者JVM内存溢出。
这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的
要理解Java
异常处理是如何工作的,你需要掌握以下三种类型的异常:
- Exception(编译时异常/检查性异常):
在执行Javac.exe命令时,发现的异常。
最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略,需要try{}catch{}或者throws处理 - Runtime Exception (运行时异常/非检查性异常):
在执行Java.exe命令时,出现的异常。
运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。可以不需要try{}catch{}或者throws处理 - 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
Exception 类的层次
所有的异常类是从java.lang.Exception
类继承的子类。
Exception
类是 Throwable
类的子类。除了Exception
类外,Throwable
还有一个子类Error
。Java
程序通常不捕获错误。错误一般发生在严重故障时,它们在Java
程序处理的范畴之外。
Error
用来指示运行时环境发生的错误。
例如,JVM
内存溢出。一般地,程序不会从错误中恢复。
异常类有两个主要的子类:IOException
类和 RuntimeException
类。
在 Java
内置类中,有大部分常用检查性和非检查性异常。
Java 内置异常类
Java
语言定义了一些异常类在 java.lang
标准包中。
标准运行时异常类的子类是最常见的异常类。由于 java.lang
包是默认加载到所有的 Java
程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。
Java
根据各个类库也定义了一些其他的异常,下面的表中列出了 Java
的非检查性异常。
异常 | 描述 |
---|---|
ArithmeticException | 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。 |
ArrayIndexOutOfBoundsException | 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。 |
ArrayStoreException | 试图将错误类型的对象存储到一个对象数组时抛出的异常。 |
ClassCastException | 当试图将对象强制转换为不是实例的子类时,抛出该异常。 |
IllegalArgumentException | 抛出的异常表明向方法传递了一个不合法或不正确的参数。 |
IllegalMonitorStateException | 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。 |
IllegalStateException | 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。 |
IllegalThreadStateException | 线程没有处于请求操作所要求的适当状态时抛出的异常。 |
IndexOutOfBoundsException | 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。 |
NegativeArraySizeException | 如果应用程序试图创建大小为负的数组,则抛出该异常。 |
NullPointerException | 当应用程序试图在需要对象的地方使用 null 时,抛出该异常 |
NumberFormatException | 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。 |
SecurityException | 由安全管理器抛出的异常,指示存在安全侵犯。 |
StringIndexOutOfBoundsException | 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。 |
UnsupportedOperationException | 当不支持请求的操作时,抛出该异常。 |
下面的表中列出了 Java
定义在 java.lang
包中的检查性异常类。
异常 | 描述 |
---|---|
IOException | 读取文件不存在 |
ClassNotFoundException | 应用程序试图加载类时,找不到相应的类,抛出该异常。 |
CloneNotSupportedException | 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。 |
IllegalAccessException | 拒绝访问一个类的时候,抛出该异常。 |
InstantiationException | 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。 |
InterruptedException | 一个线程被另一个线程中断,抛出该异常。 |
NoSuchFieldException | 请求的变量不存在 |
NoSuchMethodException | 请求的方法不存在 |
异常方法
下面的列表是 Throwable
类的主要方法:
序号 | 方法及说明 |
---|---|
1 | public String getMessage() |
- | 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 |
2 | public Throwable getCause() |
- | 返回一个Throwable 对象代表异常原因。 |
3 | public String toString() |
- | 使用getMessage()的结果返回类的串级名字。 |
4 | public void printStackTrace() |
- | 打印toString()结果和栈层次到System.err,即错误输出流。 |
5 | public StackTraceElement [] getStackTrace() |
- | 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。 |
6 | public Throwable fillInStackTrace() |
- | 用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。 |
Java异常处理的方式
try-catch-finally 捕获异常
使用 try
和 catch
关键字可以捕获异常。try/catch
代码块放在异常可能发生的地方。
try/catch
代码块中的代码称为保护代码,使用 try/catch
的语法如下:
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
Catch
语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时,try
后面的 catch
块就会被检查。
如果发生的异常包含在 catch
块中,异常会被传递到该 catch
块,这和传递一个参数到方法是一样。多个catch,父类的catch放到最下面。即catch (Exception e) {}
放在最后
catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。当捕获到的异常,本功能处理不了时,可以继续在catch中throw抛出
try{
throw new AException();
}catch (AException e){
throw e;
}
/** 如果该异常处理不了,但并不属于该功能出现的异常。可以将异常转换后,在抛出和该功能相关的异常。
或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,当调用者知道。并处理。也可以将捕获异常处理后,转换新的异常。**/
try{
throw new AException();
}catch (AException e){
// 对AException处理。
throw new BException();
}
一个try对应多个catch情况分析
try {
throw new BusinessException("404");
} catch (BusinessException e) {
log.info("BusinessException执行");
} catch (RuntimeException e) {
log.info("RuntimeException执行");
} catch (Exception e) {
log.info("Exception执行");
} finally{
// 1、关闭连接 2、解除锁
}
BusinessException类
public class BusinessException extends RuntimeException {
public BusinessException(String message) {
super(message);
}
}
BusinessException继承了RuntimeException,RuntimeException继承了Exception
代码示例如下
public static void main(String[] args) {
try {
throw new BusinessException("404");
} catch (BusinessException e) {
log.info("BusinessException执行");
} catch (RuntimeException e) {
log.info("RuntimeException执行");
} catch (Exception e) {
log.info("Exception执行");
} finally{
// 1、关闭连接 2、解除锁
}
}
结论:
1、try代码块中抛出的异常catch代码块会精确匹配。比如抛出BusinessException异常会命中catch (BusinessException e) {}代码块,最后执行finally{}代码块。抛出RuntimeException 异常会命中catch (RuntimeException e) {}代码块,最后执行finally{}代码块。抛出Exception 异常会命中catch (Exception e) {}代码块,最后执行finally{}代码块。
2、try代码块中抛出的异常catch代码块没有精确匹配,则会命中父类。如下,抛出BusinessException异常会命中catch (RuntimeException e) {}代码块,最后执行finally{}代码块。
try {
throw new BusinessException("404");
} catch (RuntimeException e) {
log.info("RuntimeException执行");
} catch (Exception e) {
log.info("Exception执行");
} finally{
// 1、关闭连接 2、解除锁
}
3、try代码块中抛出的异常catch代码块没有精确匹配,也没有匹配的父类,则会命中父类的父类,不断寻找,直到命中一个catch(){}代码块。
try {
throw new BusinessException("404");
} catch (Exception e) {
log.info("Exception执行");
} finally{
// 1、关闭连接 2、解除锁
}
4、如果异常子类的优先级比父类高/异常子类在异常父类的后面,idea编译器会提示报错。
项目开发中日志框架记录异常的正确方式
项目中有的时候会用try catch包裹错误,然后即使出错也让流程继续走下去,但是为了及时知道错误需要把错误日志打印出来,然后有一天忽然发现错误日志根本在服务器中都没有打印出来
以前错误记录日志的方式
public static void main(String[] args) {
try {
int i = 1/0;
} catch (Exception e) {
//打印堆栈信息
e.printStackTrace();
//打印错误日志
log.error("业务运行异常: {}", e.getMessage());
}
}
正确记录日志的方式
public static void main(String[] args) {
try {
int i = 1/0;
} catch (Exception e) {
//打印错误日志
log.error("业务运行异常: ", e);
}
}
注意应使用正确的error方法,传入两个参数,参数1是对异常的附加描述,参数2是未被篡改过的异常对象
finally关键字
finally
关键字用来创建在 try
代码块后面执行的代码块,无论是否发生异常,finally
代码块中的代码总会被执行。 在 finally
代码块中,可以运行清理类型等收尾善后性质的语句。
我们在开发中,有一些资源(比如﹔输入流、输出流,数据库连接、Socket连接等资源),在使用完以后,必须显式的进行关闭操作,否则,GC不会自动的回收这些资源。进而导致内存的泄漏。为了保证这些资源在使用完以后,不管是否出现了未被处理的异常的情况下,这些资源能被关闭。我们必须将这些操作声明在finally中
finally
代码块出现在 catch
代码块最后,语法如下:
try{
// 程序代码
}catch(异常类型1 异常的变量名1){
// 程序代码
}catch(异常类型2 异常的变量名2){
// 程序代码
}finally{
// 程序代码
}
案例1
private static int finally1(String num) {
try {
System.out.println("执行try代码块,解析方法之前");
Integer.parseInt(num);
System.out.println("执行try代码块,解析方法之后");
return 1;
} catch (NumberFormatException e) {
System.out.println("执行catch代码块");
return -1;
} finally {
System.out.println("执行finally代码块");
return -2;
}
}
调用1:
public static void main(String[] args) {
System.out.println(finally1("1"));
}
调用2:
public static void main(String[] args) {
System.out.println(finally1("a"));
}
案例2
public static void main(String[] args) {
System.out.println(finally2(10));
}
private static int finally2(Integer num) {
try {
System.out.println("执行try代码块");
return num++;
} catch (NumberFormatException e) {
System.out.println("执行catch代码块");
return -1;
} finally {
System.out.println("执行finally代码块");
return num;
}
}
private static int finally3(Integer num) {
try {
System.out.println("执行try代码块");
return num++;
} catch (NumberFormatException e) {
System.out.println("执行catch代码块");
return -1;
} finally {
System.out.println("执行finally代码块");
num++;
}
}
注意下面事项:
catch
不能独立于try
存在。- 在
try/catch
后面添加finally
块并非强制性要求的。 try
代码后不能既没catch
块也没finally
块。try, catch, finally
块之间不能添加任何代码。
throws+异常类型 抛出
1、使用 throw
关键字抛出一个检查性异常Exception
或其子类,无论它是新实例化的还是刚捕获到的。那么该方法必须使用 throws
关键字来声明异常。抛出(非检查性异常)运行时异常(RuntimeException),方法无需使用 throws关键字来声明异常
public static void testTry() throws RemoteException {
throw new RemoteException();
}
2、如果一个方法没有捕获到一个检查性异常Exception
或其子类,那么该方法必须使用 throws
关键字来声明。throws
关键字放在方法签名的尾部。
public static void main(String[] args) throws RemoteException {
testTry();
}
RemoteException 是Exception的子类
项目开发中抛出异常的正确方式
在某些情况下,可能需要在处理异常后继续抛出,让上层捕获后继续处理,在这种情况下,需要注意抛出的异常对象未被篡改
以前错误抛出异常的方式
public static void main(String[] args) throws Exception {
try {
int i = 1/0;
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}
如果像上图这样写的话,下层的异常stacktrace会全部被吃掉。
正确抛出异常的方式
public static void main(String[] args) {
try {
int i = 1/0;
} catch (Exception e) {
throw e;
}
}
开发中,如何选择异常处理的两种方式
1、如果程序代码中,涉及到资源的调用(流、数据库连接、网络连接等),则必须考虑使用try-catch-finally
来处理,保证不出现内存泄漏。
2、如果父类被重写的方法没有throws
异常类型,则子类重写的方法中如果出现异常,只能考虑使用try-catch-finally
进行处理,不能throws
。
3、开发中,方法a中依次调用了方法b , c , d等方法,方法b , c , d之间是递进关系。此时,如果方法b, c , d中有异常,我们通常选择使用throws,而方法a中通常选择使用try-catch-finally
throw手动抛出异常对象
在实际开发中,如果出现不满足具体场景的代码问题,我们就有必要手动抛出一个指定类型的异常对象。
public static void main(String[] args) {
test(0);
}
private static int test(int num) {
if (num > 1) {
System.out.println("执行业务逻辑!");
} else {
throw new RuntimeException("程序错误!");
}
return num;
}
自定义异常
在 Java
中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
- 所有异常都必须是 Throwable 的子类。
- 如果希望写一个检查性异常类,则需要继承
Exception
类。 - 如果你想写一个运行时异常类,那么需要继承
RuntimeException
类。
继承Exception时,throw自定义异常时,函数上需要用throws声明。
继承RuntimeException时,throw自定义异常时,函数上可以不用throws声明,所以自定义异常继承RuntimeException方式比较常用
当要定义自定义异常的信息时,可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。
public class BusinessException extends RuntimeException {
public BusinessException(String message) {
super(message);
}
}
自定义异常好处:按照java的面向对象思想,将程序中出现的特有问题进行封装。
- 将问题进行封装。
- 将正常流程代码和问题处理代码相分离,方便于阅读。
通用异常
在Java
中定义了两种类型的异常和错误。
JVM(Java虚拟机)
异常:由JVM
抛出的异常或错误。例如:NullPointerException
类,ArrayIndexOutOfBoundsException
类,ClassCastException
类。- 程序级异常:由程序或者
API
程序抛出的异常。例如IllegalArgumentException
类,IllegalStateException
类。
异常的注意事项
- 在子父类覆盖时
- 子类抛出的异常必须是父类的异常的子类或者子集。
- 如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
final、 finally、 finalize 的区别
final
:用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,被其修饰的类不可继承。
finally
:异常处理语句结构的一部分,表示总是执行。
finalize
:Object
类的一个方法,在垃圾回收器执行的时候会调用被回收对象的此方法,可以覆盖此方法
提供垃圾收集时的其他资源回收,例如关闭文件等。该方法更像是一个对象生命周期的临终方法,当该方法
被系统调用则代表该对象即将“死亡”,但是需要注意的是,我们主动行为上去调用该方法并不会导致该对
象“死亡”,这是一个被动的方法(其实就是回调方法),不需要我们调用。