Java提高篇——Java中的异常处理
对于运行时异常、错误和检查异常,Java技术所要求的异常处理方式有所不同。
由于运行时异常及其子类的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常。
对于方法运行中可能出现的Error,当运行方法不予捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常。
对于所有的检查异常,Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉检查异常时,它必须声明将抛出异常。
Java异常处理涉及到五个关键字,分别是:try、catch、finally、throw、throws。下面将骤一介绍,通过认识这五个关键字,掌握基本异常处理知识。
try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。
catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物理资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。
throw – 用于抛出异常。
throws – 用在方法签名中,用于声明该方法可能抛出的异常。
异常处理的基本语法
=========
1. try-catch
try{
//code that might generate exceptions
}catch(Exception e){
//the code of handling exception1
}catch(Exception e){
//the code of handling exception2
}
要明白异常捕获,还要理解监控区域(guarded region)的概念。它是一段可能产生异常的代码,并且后面跟着处理这些异常的代码。
因而可知,上述try-catch所描述的即是监控区域,关键词try后的一对大括号将一块可能发生异常的代码包起来,即为监控区域。Java方法在运行过程中发生了异常,则创建异常对象。将异常抛出监控区域之外,由Java运行时系统负责寻找匹配的catch子句来捕获异常。若有一个catch语句匹配到了,则执行该catch块中的异常处理代码,就不再尝试匹配别的catch块了。
匹配的原则是:如果抛出的异常对象属于catch子句的异常类,或者属于该异常类的子类,则认为生成的异常对象与catch块捕获的异常类型相匹配。
举个例子算术异常:
public class TestException {
public static void main(String[] args) {
int a = 1;
int b = 0;
try { // try监控区域
if (b == 0) throw new ArithmeticException(); // 通过throw语句抛出异常
System.out.println(“a/b的值是:” + a / b);
System.out.println(“this will not be printed!”);
}
catch (ArithmeticException e) { // catch捕捉异常
System.out.println(“程序出现异常,变量b不能为0!”);
}
System.out.println(“程序正常结束。”);
}
}
运行结果:
D:\java>java TestException
程序出现异常,变量b不能为0!
程序正常结束。
显示一个异常的描述,Throwable重载了toString()方法(由Object定义),所以它将返回一个包含异常描述的字符串。例如,将前面的catch块重写成:
catch (ArithmeticException e) { // catch捕捉异常
System.out.println(“程序出现异常”+e);
}
结果:
D:\java>java TestException
程序出现异常java.lang.ArithmeticException
程序正常结束。
根据前面讲述的,算术异常属于运行时异常,因而实际上该异常不需要程序抛出,运行时系统自动抛出,将例子改为如下:
public class TestException {
public static void main(String[] args) {
int a = 1;
int b = 0;
System.out.println(“a/b的值是:” + a / b);
System.out.println(“this will not be printed!”);
}}
结果:
D:\java>java TestException
Exception in thread “main” java.lang.ArithmeticException: / by zero
at TestException.main(TestException.java:7)
使用多重的catch语句:很多情况下,由单个的代码段可能引起多个异常。处理这种情况,我们需要定义两个或者更多的catch子句,每个子句捕获一种类型的异常,当异常被引发时,每个catch子句被依次检查,第一个匹配异常类型的子句执行,当一个catch子句执行以后,其他的子句将被旁路。
编写多种catch语句块注意事项:
顺序问题:先小后大,即先子类后父类
Java通过异常类描述异常类型。对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子句放在前面,同时尽量将捕获相对高层的异常类的catch子句放在后面。否则,捕获底层异常类的catch子句将可能会被屏蔽。
RuntimeException异常类包括运行时各种常见的异常,ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。因此,RuntimeException异常类的catch子句应该放在最后面,否则可能会屏蔽其后的特定异常处理或引起编译错误。
嵌套try语句:try语句可以被嵌套。也就是说,一个try语句可以在另一个try块的内部。每次进入try语句,异常的前后关系都会被推入堆栈。如果一个内部的try语句不含特殊异常的catch处理程序,堆栈将弹出,下一个try语句的catch处理程序将检查是否与之匹配。这个过程将继续直到一个catch语句被匹配成功,或者是直到所有的嵌套try语句被检查完毕。如果没有catch语句匹配,Java运行时系统将处理这个异常。
例如:
class NestTry{
public static void main(String[] args){
try{
int a = args.length;
int b = 42 / a;
System.out.println("a = "+ a);
try{
if(a == 1){
a = a/(a-a);}if(a == 2){
int c[] = {1};
c[42] =99;
}}catch(ArrayIndexOutOfBoundsException e){
System.out.println(“ArrayIndexOutOfBounds :”+e);
}}catch(ArithmeticException e){
System.out.println(“Divide by 0”+ e);
}}}
正如程序中所显示的,该程序在一个try块中嵌套了另一个try块。程序工作如下:当你在没有命令行参数的情况下执行该程序,外面的try块将产生一个被0除的异常。程序在有一个命令行参数条件下执行,由嵌套的try块产生一个被0除的异常,由于内部的catch块不匹配这个异常,它将把异常传给外部的try块,在外部异常被处理。如果你在具有两个命令行参数的条件下执行该程序,将由内部try块产生一个数组边界异常。
结果:
D:\java>javac estTry.java
D:\java>>java NestTryDivide by 0 java.lang.ArithmeticExceptio: / by zero
D:\java>java NestTry onea = 1
Divide by 0java.lang.ArithmeticException: / by zero
D:\java>java NestTry one twoa = 2
ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42
注意:
当有方法调用时,try语句的嵌套可以很隐蔽的发生。例如,我们可以将对方法的调用放在一个try块中。在该方法的内部,有另一个try语句。在这种情况下,方法内部的
【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】浏览器打开:qq.cn.hn/FTf 免费领取
try仍然是嵌套在外部调用该方法的try块中的。下面我们将对上述例子进行修改,嵌套的try块移到方法nesttry()的内部:
class NestTry{
static void nesttry(int a){
try{
if(a == 1){
a = a/(a-a);}if(a == 2){
int c[] = {1};
c[42] =99;
}}catch(ArrayIndexOutOfBoundsException e){
System.out.println(“ArrayIndexOutOfBounds :”+e);
}}public static void main(String[] args){
try{
int a = args.length;
int b = 42 / a;
System.out.println("a = "+ a);
nesttry(a);}catch(ArithmeticException e){
System.out.println(“Divide by 0”+ e);
}}}
结果输出与前面例子一致:
D:\java>javac NestTry.java
D:\java>java NestTryDivide by 0java.lang.ArithmeticException: / by zero
D:\java>java NestTry onea = 1
Divide by 0java.lang.ArithmeticException: / by zero
D:\java>java NestTry one twoa = 2
ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42
}
2. throw
到目前为止,我们只是获取了被Java运行时系统引发的异常。然而,我们还可以用throw语句抛出明确的异常。Throw的语法形式如下:
throw ThrowableInstance;
这里的ThrowableInstance一定是Throwable类类型或者Throwable子类类型的一个对象。简单的数据类型,例如int,char,以及非Throwable类,例如String或Object,不能用作异常。有两种方法可以获取Throwable对象:在catch子句中使用参数或者使用new操作符创建。
程序执行完throw语句之后立即停止;throw后面的任何语句不被执行,最邻近的try块用来检查它是否含有一个与异常类型匹配的catch语句。如果发现了匹配的块,控制转向该语句;如果没有发现,以包围的try块来检查,以此类推。如果没有发现匹配的catch块,默认异常处理程序中断程序的执行并且打印堆栈轨迹。
例如:
class TestThrow{
static void proc(){
try{
throw new NullPointerException(“demo”);
}catch(NullPointerException e){
System.out.println(“Caught inside proc”);
throw e;
}}public static void main(String [] args){
try{
proc();}catch(NullPointerException e){
System.out.println("Recaught: "+e);
}}}
结果:
D:\java>java TestThrow
Caught inside proc
Recaught: java.lang.NullPointerException: demo
该程序两次处理相同的错误,首先,main()方法设立了一个异常关系然后调用proc()。proc()方法设立了另一个异常处理关系并且立即抛出一个NullPointerException实例,NullPointerException在main()中被再次捕获。
该程序阐述了怎样创建Java的标准异常对象,特别注意这一行:
throw new NullPointerException(“demo”);
此处new用来构造一个NullPointerException实例,所有的Java内置的运行时异常有两个构造方法:一个没有参数,一个带有一个字符串参数。当用第二种形式时,参数指定描述异常的字符串。如果对象用作print()或者println()的参数时,该字符串被显示。这同样可以通过调用getMessage()来实现,getMessage()是由Throwable定义的。
3. throws
如果一个方法可以导致一个异常但不处理它,它必须指定这种行为以使方法的调用者可以保护它们自己而不发生异常。要做到这点,我们可以在方法声明中包含一个throws子句。一个throws子句列举了一个方法可能引发的所有异常类型。这对于除了Error或RuntimeException及它们子类以外类型的所有异常是必要的。一个方法可以引发的所有其他类型的异常必须在throws子句中声明,否则会导致编译错误。
下面是throws子句的方法声明的通用形式:
public void info() throws Exception
{//body of method
}
Exception 是该方法可能引发的所有的异常,也可以是异常列表,中间以逗号隔开。
例如:
class TestThrows{
static void throw1(){
System.out.println("Inside throw1 . ");
throw new IllegalAccessException(“demo”);
}public static void main(String[] args){
throw1();}}
上述例子中有两个地方存在错误,你能看出来吗?
该例子中存在两个错误,首先,throw1()方法不想处理所导致的异常,因而它必须声明throws子句来列举可能引发的异常即IllegalAccessException;其次,main()方法必须定义try/catch语句来捕获该异常。
正确例子如下:
class TestThrows{
static void throw1() throws IllegalAccessException {
System.out.println("Inside throw1 . ");
throw new IllegalAccessException(“demo”);
}public static void main(String[] args){
try {
throw1();}catch(IllegalAccessException e ){
System.out.println("Caught " + e);
}}}
Throws抛出异常的规则:
如果是不受检查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。
必须声明方法可抛出的任何检查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误
仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。
调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
4. finally
当异常发生时,通常方法的执行将做一个陡峭的非线性的转向,它甚至会过早的导致方法返回。例如,如果一个方法打开了一个文件并关闭,然后退出,你不希望关闭文件的代码被异常处理机制旁路。finally关键字为处理这种意外而设计。
finally创建的代码块在try/catch块完成之后另一个try/catch出现之前执行。finally块无论有没有异常抛出都会执行。如果抛出异常,即使没有catch子句匹配,finally也会执行。一个方法将从一个try/catch块返回到调用程序的任何时候,经过一个未捕获的异常或者是一个明确的返回语句,finally子句在方法返回之前仍将执行。这在关闭文件句柄和释放任何在方法开始时被分配的其他资源是很有用。
finally子句是可选项,可以有也可以无,但是每个try语句至少需要一个catch或者finally子句。
class TestFinally{
static void proc1(){
try{
System.out.println(“inside proc1”);
throw new RuntimeException(“demo”);
}finally{
System.out.println(“proc1’s finally”);
}}static void proc2(){
try{
System.out.println(“inside proc2”);
return ;
} finally{
System.out.println(“proc2’s finally”);
}}static void proc3(){
try{
System.out.println(“inside proc3”);
}finally{
System.out.println(“proc3’s finally”);
}}public static void main(String [] args){
try{
proc1();}catch(Exception e){
System.out.println(“Exception caught”);
Java提高篇——Java中的异常处理相关推荐
- Java提高篇 —— Java三大特性之继承
一.前言 在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事 ...
- Java提高篇——Java实现多重继承
多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承.有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需 ...
- Java提高篇——Java 异常处理
异常的概念 异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的. 比如说,你的代码少了一个分号,那么运行出来结果是提示是错误java.lang.Error:如果你用Syst ...
- Java提高篇 —— Java关键字之final的几种用法
一.前言 在java的关键字中,static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构.下面我们来了解一下 ...
- Java提高篇 —— Java内部类详解
一.简介 内部类是一个非常有用的特性但又比较难理解使用的特性. 内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类. public class OuterClass {privat ...
- Java提高篇 —— Java关键字之static的四种用法
一.前言 在java的关键字中,static和final是两个我们必须掌握的关键字.不同于其他关键字,他们都有多种用法,而且在一定环境下使用,可以提高程序的运行性能,优化程序的结构.下面我们先来了解一 ...
- Java提高篇 ——Java注解
目录 一.注解 注解的定义 注解的应用 元注解 @Retention @Documented @Target @Inherited @Repeatable 注解的属性 Java 预置的注解 @Depr ...
- Java提高篇 —— Java浅拷贝和深拷贝
一.前言 我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快,特别是在大对象的生成上,使得性能 ...
- Java提高篇 —— Java三大特性之多态
一.前言 面向对象编程有三大特性:封装.继承.多态. 封装:隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据.对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问 ...
最新文章
- 关于Titandb Ratelimiter 失效问题的一个bugfix
- 数据在java中加时间,如何在Or.jFr.DATA时间中设置RealTimeMead时期的Java数据
- OpenGL抗锯齿实例
- MyBatis 源码解读-带着问题去看源码
- (一四三)类设计回顾
- uni-app 更新包提示HTML5+Runtime缺少升级包manifest.json中配置的模块:payment
- Spring系列(五):@Lazy懒加载注解用法介绍
- 字符串的存储方式以及静态存储区域、栈、堆
- csp 201712-1 最小差值
- SQL 2008 FileStream数据类型
- 编译ffmpeg:no match insn: lbu $r16,0($r5)
- 导出excel用ajax不行,提交form表单可以
- Office 2010 文件验证
- 数据库的挂起(suspending)和恢复(resuming)
- 第35讲:Xposed+模拟器的详细使用
- 亚马逊服务器个人文档,AmazonAWS入门-文档.PDF
- 计算机网络基本知识(八):域名、IP地址简介及分类
- 移动安全测试框架MobSF(二):动态分析
- 捕鱼来了2017系列游戏
- 微信小程序--图片转base64