Java异常机制、Java异常的捕获顺序、Throw和Throws的区别、异常中的return
综合网上各类博客总结出来,只供学习。
Java异常的捕获顺序
package com.view.exception;
public class TestMoreCatch {
public static void main(String[] args) {
int a = 6;
int b = 0;
try { // try监控区域
if (b == 0)
throw new ArithmeticException(); // 通过throw语句抛出异常
System.out.println("a/b的值是:" + a / b);
} catch (ArithmeticException e) { // catch捕捉异常
System.out.println("程序出现异常,变量b不能为0。");//运行
} catch (Exception e) {
/**
* 范围更大的Exception不但必须放在后面
* 并且放在后面还不会被运行(被前面的范围更小的
* 异常拦截了)
*/
System.out.println("执行exception 父类的异常");
}
System.out.println("程序正常结束。");
}
}
/*
* 要点1:尽管ArithmeticException继承自Exception。可是当发生ArithmeticException异常
* 并捕获的时候,就仅仅会捕获实际发生的这个异常。并不会由于Exception是其父类而
*
* 运行Exception那个catch子句。
*
* 要点2:可是假设你尝试将范围更大的Exception的catch语句放到的catch语句的前面,那么就会发生
*
* catch子句不可到达的错误“Unreachablecatch block for ArithmeticException.
*
* Itis already handled by the catch block for Exception”
*
* 即范围更大的异常(父类)必须放在后面,假设没有继承关系,比方ClassNotFoundException,
*
* 和ArithmeticException的catch子句之间就无所谓先后关系。
*/
Throw和Throws的区别:
Throw:
作用在方法内,表示抛出具体异常,由方法体内的语句处理。
具体向外抛出的动作,所以它抛出的是一个异常实体类。若执行了Throw一定是抛出了某种异常。
Throws:
作用在方法的声明上,表示如果抛出异常,则由该方法的调用者来进行异常处理。
主要的声明这个方法会抛出会抛出某种类型的异常,让它的使用者知道捕获异常的类型。
出现异常是一种可能性,但不一定会发生异常。
实例:
void testException(int a) throws IOException,{
try{
......
}catch(Exception1 e){
throw e;
}catch(Exception2 e){
System.out.println("出错了!");
}
if(a!=b)
throw new Exception3("自定义异常");
}
异常两种处理方式
- throws 抛出异常,自己不处理
- try-catch 自己处理异常
抛出异常
谁调用抛给谁去解决
分成两步:
- 抛异常 throw new Exception(“”)
- 接异常 throws Exception
异常中的return
public class TestReturn {
public static void main(String[] args) {
System.out.println("=============NoException==================");//1
System.out.println(NoException());//2
System.out.println("==============================="); //3
}
public static int NoException(){
int i=10;
try{
System.out.println("i in try block is:"+i);//2.1
return --i; //2.2 i=9
}
catch(Exception e){
--i;
System.out.println("i in catch - form try block is:"+i);
return --i;
}
finally{
System.out.println("i in finally - from try or catch block is:"+i);//2.3
return --i;//2.4 i=8
}
}
}
1.try块中没有抛出异常,try、catch和finally块中都有return语句
执行顺序:
执行try块,执行到return语句时,先执行return的语句,--i,但是不返回到main方法,执行finally块,遇到finally块中的return语句,执行--i,并将值返回到main方法,这里就不会再回去返回try块中计算得到的值。
结论:try-catch-finally都有return语句时,没有异常时,返回值是finally中的return返回的
2.try块中没有抛出异常,仅try和catch中有return语句
执行顺序:
try中执行完return的语句后,不返回,执行finally块,finally块执行结束后,返回到try块中,返回i在try块中最后的值。
结论:try-catch都有return语句时,没有异常时,返回值是try中的return返回的。
public class TestReturn02 {
public static void main(String[] args) {
System.out.println("=============NoException==================");// 1
System.out.println(HaveException());// 2
System.out.println("==============================="); // 3
}
public static int HaveException() {
int i = 10;
try {
System.out.println("i in try block is:" + i);// 2.1
i = i / 0;
return --i;
} catch (Exception e) {
System.out.println("i in catch - form try block is:" + i);// 2.2
--i;
System.out.println("i in catch block is:" + i);// 2.3
return --i;// 2.4
} finally {
System.out.println("i in finally - from try or catch block is--" + i);// 2.5
--i;
System.out.println("i in finally block is--" + i);// 2.6
return --i;// 2.7
}
}
}
3.try块中抛出异常,try、catch和finally中都有return语句
执行顺序:
抛出异常后,执行catch块,在catch块的return的--i执行完后,并不直接返回而是执行finally,因finally中有return语句,所以,执行,返回结果6。
结论:try块中抛出异常,try、catch和finally中都有return语句,返回值是finally中的return。
4.try块中抛出异常,try和catch中都有return语句
执行顺序:
抛出异常后,执行catch块,执行完finally语句后,依旧返回catch中的执行return语句后的值,而不是finally中修改的值。
结论:返回的catch中return值。
public class TestReturn03 {
public static void main(String[] args) {
System.out.println("=============NoException==================");// 1
System.out.println(HaveException03());// 2
System.out.println("==============================="); // 3
}
public static int HaveException03() {
int i = 10;
try {
System.out.println("i in try block is:" + i);//2.1
i = i / 0;
return --i;
} catch (Exception e) {
System.out.println("i in catch - form try block is:" + i);//2.2
int j = i / 0;
return --i;
} finally {
System.out.println("i in finally - from try or catch block is:" + i);//2.3
--i; //2.4
System.out.println("i in finally block is:" + i);//2.5
return --i; //2.6
}
}
}
5.try、catch中都出现异常,在finally中有返回
执行顺序:
try块中出现异常到catch,catch中出现异常到finally,finally中执行到return语句返回,不检查异常。
结论:返回finally中return值。
6.只在函数最后出现return语句
结论:返回函数最后的return语句
总体结论:
结论一:
return语句并不是函数的最终出口,如果有finally语句,这在return之后还会执行finally(return的值会暂存在栈里面,等待finally执行后再返回)
结论二:
finally里面不建议放return语句,根据需要,return语句可以放在try和catch里面和函数的最后。可行的做法有四:
(1)return语句只在函数最后出现一次。
(2)return语句仅在try和catch里面都出现。
(3)return语句仅在try和函数的最后都出现。
(4)return语句仅在catch和函数的最后都出现。
注意,除此之外的其他做法都是不可行的,编译器会报错。