技术标签: Java java throw Exception
作为一位初学者, 本屌也没有能力对异常谈得很深入. 只不过java里关于Exception的东西实在是很多. 所以这篇文章很长就是了..
#include <stdio.h>
int f(int a, int b){
return a/b;
}
int main(){
int i = f(8,0);
printf("i is %d\n",i);
return 0;
}
package Exception_kng;
class Exp1{
public int f(int a, int b){
return a/b;
}
}
public class Expt_1{
public static void g(){
Exp1 e = new Exp1();
int i = e.f(8,0);
System.out.printf("i is %d\n", i);
}
}
[java] Caused by: java.lang.ArithmeticException: / by zero
[java] at Exception_kng.Exp1.f(Expt_1.java:5)
[java] at Exception_kng.Expt_1.g(Expt_1.java:12)
[java] at Enter_1.main(Enter_1.java:31)
package Exception_kng;
class Exp2{
public int f(int a, int b){
int i = 0;
try{
i = a/b;
}
catch(Exception e){
System.out.printf("Exception occurs!!\n");
System.out.println(e.getMessage()); //print the root cause
System.out.printf("===========================\n");
e.printStackTrace(); //print the info of function stuck.
}
return i;
}
}
public class Expt_2{
public static void g(){
Exp2 ex = new Exp2();
int i = ex.f(8,0); //call f()
System.out.printf("i is %d\n", i); //successfully executed
}
}
[java] Exception occurs!!
[java] / by zero
[java] ===========================
[java] java.lang.ArithmeticException: / by zero
[java] at Exception_kng.Exp2.f(Expt_2.java:7)
[java] at Exception_kng.Expt_2.g(Expt_2.java:23)
[java] at Enter_1.main(Enter_1.java:31)
[java] i is 0
package Exception_kng;
class Exp3{
public int f(int a, int b){
if (0 == b){
throw new ArithmeticException("Shit !!! / by zero!");
}
return a/b;
}
}
public class Expt_3{
public static void g() throws ArithmeticException{
Exp3 ex = new Exp3();
int i = 22;
i = ex.f(8,0); //throw excetpion
System.out.printf("i is %d\n", i); //failed executed
System.out.printf("g() is done!!\n"); //failed executed
}
public static void h(){
try{
g();
}catch(ArithmeticException e){
System.out.printf("Exception occurs!!\n");
System.out.println(e.getMessage()); //print the root cause
System.out.printf("===========================\n");
e.printStackTrace(); //print the info of function stuck.
}
System.out.printf("h() is done!!\n"); //successfully executed
}
}
[java] Exception occurs!!
[java] Shit !!! / by zero!
[java] ===========================
[java] java.lang.ArithmeticException: Shit !!! / by zero!
[java] at Exception_kng.Exp3.f(Expt_3.java:6)
[java] at Exception_kng.Expt_3.g(Expt_3.java:18)
[java] at Exception_kng.Expt_3.h(Expt_3.java:25)
[java] at Enter_1.main(Enter_1.java:31)
[java] h() is done!!
try{
f();
ff();
}
catch(ArithmeticException e){
g();
}
catch(IOException e){
gg();
}
catch(AuthorizedException e){
ggg();
}
finally{
h();
}
k();
这种情况很简单, 就是try{}里面的代码被完整执行, 因为没有抛出任何异常, 就不会尝试执行catch里的部分, 直接到finally部分了.
路线是:
f() -> ff() -> h() -> k()
也许有人会问, 我们怎么知道到底会抛出什么异常?
下面有3个解决方案.
1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.
2.在catch的括号里写上Exception e, 毕竟Exception 是所有其他异常的超类, 这里涉及多态的知识, 至于什么是多态可以看看本人的另一篇文章.
3. 观察被调用函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常
包括我在内很多人会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执行, 上面那个例子里的h()为什么不跟下面的k() 写在一起呢.
上面的例子的确看不出区别.
但下面两种情况下就体现了finally独特的重要性.
例如try里面抛出了1个A异常, 但是只有后面只有捕捉B异常, 和C异常的子句.
这种情况下, 程序直接执行finally{}里的子句, 然后中断当前函数, 把异常抛给上一级函数, 所以当前函数finally后面的语句不会被执行.
例子:
package Exception_kng;
import java.net.*;
import java.io.*;
class Exp4{
public int f(int a, int b) throws IOException, BindException{
return a/b;
}
}
public class Expt_4{
public static void g(){
Exp4 ex = new Exp4();
int i = 22;
try{
System.out.printf("g() : try!!\n"); //failed
i = ex.f(8,0); //call f()
}
catch(BindException e){
System.out.printf("g() : BindException!!\n"); //failed
}
catch(IOException e){
System.out.printf("g() : IOException!!\n"); //failed
}
finally{
System.out.printf("g() : finaly!!\n"); //successfully executed
}
System.out.printf("g() is done!!\n"); //failed
}
public static void h(){
try{
g();
}catch(ArithmeticException e){
System.out.printf("Exception occurs!!\n");
System.out.println(e.getMessage()); //print the root cause
System.out.printf("===========================\n");
e.printStackTrace(); //print the info of function stuck.
}
System.out.printf("h() is done!!\n"); //successfully executed
}
}
所以这个异常会中断g()的执行, 因为没有被捕捉到, 然后抛给调用g()的 h()函数处理, 而在h()捕捉到了, 所以h()函数是能完整执行的.
也就是说g()里的
System.out.printf("g() is done!!\n"); //failed
执行失败
而h()里的
System.out.printf("h() is done!!\n"); //successfully executed
但是无论如何, g()里的finally{}部分还是被执行了
执行结果如下:
[java] g() : try!!
[java] g() : finaly!!
[java] Exception occurs!!
[java] / by zero
[java] ===========================
[java] java.lang.ArithmeticException: / by zero
[java] at Exception_kng.Exp4.f(Expt_4.java:8)
[java] at Exception_kng.Expt_4.g(Expt_4.java:18)
[java] at Exception_kng.Expt_4.h(Expt_4.java:34)
[java] at Enter_1.main(Enter_1.java:31)
[java] h() is done!!
这种情况是1中编程的低级错误, 在项目中是不允许出现.
避免方法也十分简单, 在catch子句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.
下面例子:
try{
f();
ff();
}
catch(ArithException e){
g();
return j();
}
catch(IOException e){
gg();
return j();
}
catch(AuthorizedException e){
ggg();
return j();
}
finally{
h();
}
k();
那么执行路线就是
f() -> gg() -> j() -> h() -> 上一级function
也就说, 这种情况下finally里的子句会在return回上一级function前执行. 而后面的k()就被放弃了.
可以看出, finally里的语句, 无论如何都会被执行.
至有两种情况除外, 一是断电, 二是exit函数.
这个上面提到过了, 一旦捕捉到1个异常, 就不会尝试捕捉其他异常.
如果try里面的一段代码可能抛出3种异常A B C,
首先看它先抛出哪个异常, 如果先抛出A, 如果捕捉到A, 那么就执行catch(A)里的代码. 然后finally.. B和C就没有机会再抛出了.
如果捕捉不到A, 就执行finally{}里的语句后中断当前函数, 抛给上一级函数...(应该避免)
两种情况, 1就是没有异常抛出, 另一种就是抛出了异常但是没有捕捉不到(应该避免)
加入try 里面尝试捕捉两个异常, 1个是A, 1个是B, 但是A是B的父类.
这种情况下, 应该把catch(B)写在catch(A)前面.
原因也很简单, 加入把catch(A)写在前面, 因为多态的存在, 即使抛出了B异常, 也会被catch(A)捕捉, 后面的catch(B)就没有意义了.
也就是说如果捕捉Exception这个异常基类, 应该放在最后的catch里, 项目中也强烈建议这么做, 可以避免上述4.3.1的情况出现.
这个没什么好说的. 语法规则
每1个异常对象只能由catch它的catch子句里访问.
跟if类似, 不多说了.
这个也不难理解..
下面开始详讲异常另一种处理方法throw 和 throws了.
注意的是, 这两种用法都没有真正的处理异常, 真正处理的异常方法只有try catch, 这两种方法只是交给上一级方法处理.
就如一个组织里 , 有1个大佬, 1个党主, 1个小弟.
大佬叫党主干活, 堂主叫小弟干活, 然后小弟碰上麻烦了, 但是小弟不会处理这个麻烦, 只能中断工作抛给党主处理, 然后堂主发现这个麻烦只有大佬能处理, 然后抛给大佬处理..
道理是相通的..
throws的语法很简单.
语法:
throw new XException();
其中xException必须是Exception的派生类.
这里注意throw 出的是1个异常对象, 所以new不能省略
作用就是手动令程序抛出1个异常对象.
public int f(int a, int b){
if (0 == b){
throw new ArithmeticException("Shit !!! / by zero!");
}
return a/b;
}
public void g(){
int i;
h();
i = f(); //recevie excepton
k();
}
例如上没的g()函数, 在调用f() 会收到1个异常.
这时g()函数有三种选择.
1. 不做任何处理
这时, g()收到f()里抛出的异常就会打断g()执行, 也就是说g()里面的k(); 被放弃了, 然后程序会继续把这个函数抛给调用g()函数.
然后一级一级寻求处理, 如果都不处理, 则抛给jvm处理. jvm会中断程序, 输出异常信息. 这个上没提到过了.
2. 使用try catch处理
如果catch成功, 则g()函数能完整执行, 而且这个异常不会继续向上抛.
如果catch失败(尽量避免), 则跟情况1相同.
public int f(int a, int b){
if (0 == b){
throw new IOException("Shit !!! / by zero!");
}
return a/b;
}
注意 这里, IOException虽然逻辑上是错误的(完全不是IO的问题嘛), 但是在程序中完全可行, 因为程序猿可以根据需要控制程序指定抛出任何1个异常.
但是这段代码编译失败, 因为IOException 不是 RuntimeException的派生类.
java规定:
改成这样就正确了:
public int f(int a, int b) throws IOException{
if (0 == b){
throw new IOException("Shit !!! / by zero!");
}
return a/b;
}
例如抄回上面的例子, g()调用f()函数.
public void g(){
int i;
h();
i = f(); //recevie excepton
k()
}
处理方法有两种:
1. try catch自己处理:
public void g(){
int i = 0;
h();
try{
i = f(); //recevie excepton
}
catch(IOException e){
}
k();
}
.
public void g() throws IOException{
int i = 0;
h();
i = f(); //recevie excepton
k();
}
这是调用g()的函数也要考虑上面的这两种处理方法了...
但是最终上级的方法(main 方法)还是不处理的话, 就编译失败, 上面说过了, 非runtimeException无法抛给jvm处理.
虽然这两种处理方法都能通过编译, 但是运行效果是完全不同的.
第一种, g()能完整执行.
第二种, g()被中断, 也就是g()里面的k(); 执行失败.
throws稍微比throw难理解点:
语法是:
public void f() throws Exception1, Exception2...{
}
也就是讲, thorws可以加上多个异常, 注意这里抛出的不是对象, 不能加上new.
而且不是告诉别人这个函数有可能抛出这么多个异常. 而是告诉别人, 有可能抛出这些异常的其中一种.
如果为f()函数加上throws后续, 则告诉调用f()的方法, f()函数有可能抛出这些异常的一种.
如果f()throws 了1个或若干个非RuntimeException, 则调用f()的函数必须处理这些非RuntimeException, 如上面的g()函数一样.
如果f() throws的都是RuntimeException, 则调用f()的函数可以不处理, 也能通过编译, 但是实际上还是强烈建议处理它们.
实际上, 如果1个方法f() throws A,B
那么它有可能不抛出任何异常.(程序运行状态良好)
也有能抛出C异常(应该避免, 最好在throws上加上C)
这个是强制, 告诉别人这个函数内有炸弹.
这个是非强制的, 但是如果你知道一个函数内的代码有可能抛出异常, 最好还是写上throws 后缀
无论这个异常是否runtimeExcepion.
个人建议, 如果你调用1个函数throws A, B, C
那么你就在当前函数写上
try
catch(A)
catch(B)
catch(C)
catch(Exception)
这样能处理能保证你的函数能完整执行, 不会被收到的异常中断.
当然如果你允许你的函数可以被中断, 那么就可以在当前函数定义加上throws A, B 继续抛给上一级的函数.
例如你在一个派生类重写一个方法f(), 在超类里的f() throws A, B 你重写方法时就不throws出 A,,B,C 或者throws A和B的超类.
原因也是由于多态的存在.
因为1个超类的引用可以指向1个派生类的对象并调用不同的方法. 如果派生类throws的范围加大
那么利用多态写的代码的try catch就不再适用.
应付面试官.
所以throw后面的一般加上new 和exception名字().
而throws后面不能加上new的
因为一旦一个函数throw出1个异常, 这个函数就会被中断执行, 后面的代码被放弃, 如果你尝试在函数内写两个throw, 编译失败.
而throws 是告诉别人这个函数有可能抛出这几种异常的一种. 但是最多只会抛出一种.
原因上面讲过了.
我们可以自定义异常, 只需要编写1个类, 继承1个异常类就ok
例子:
package Exception_kng;
class User_Exception1 extends ArithmeticException{
public User_Exception1(String Exception_name){
super(Exception_name);
}
public void printStackTrace(){ //overwrite
super.printStackTrace();
System.out.printf("hey man, i am an user_defined excetpion\n");
}
}
class Exp6{
public int f(int a, int b){
if (0 == b){
throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception
}
return a/b;
}
}
public class Expt_6{
public static void g() {
Exp6 ex = new Exp6();
int i = 22;
try{
i = ex.f(8,0); //throw excetpion
}catch(User_Exception1 e){
e.printStackTrace();
}
System.out.printf("i is %d\n", i);
System.out.printf("g() is done!!\n");
}
}
上面的类User_Exception1 就是1个自定义异常, 并重写了printStackTrace()方法.
我们要理解异常的优缺点, 首先看看没有异常的c语言是如何处理错误的.
下面是个例子:
//openfile
if (fileOpen() > 0){
//check the length of the file
if (gotLengthOfTheFile() > 0){
//check the memory
if (gotEnoughMemory() > 0){
//load file to memory
if (loadFileToMem() > 0){
readFile();
}else{
errorCode = -5;
}
}else{
errorCode = -5;
}
}else{
errorCode = -5;
}
}else{
errorCode = -5;
}
//handle error
case errorCode....
//release Source
releaseSource();
可以见到c语言处理错误有这些特点
1. 大部分精力都在错误处理.
2. 需要把各种可能出现的错误全部考虑到, 才能保证程序的稳定性.
3. 程序可读性差, 错误处理代码混杂在其他代码中.
4. 出错返回信息少, 一旦出错难以调试.
5. 一旦出现了未考虑到的错误, 资源释放代码无法执行.
try{
fileOpen();
gotLengthOfTheFile();
gotEnoughMemory();
loadFileToMem();
readFile();
}
catch(fileOpenFail) { handle1()}
catch(gotLengthOfTheFileFail) { handle2()}
catch(gotEnoughMemoryFail) { handle3()}
catch(loadFileToMemFail) { handle4()}
catch(readFileFail) { handle4()}
catch(Exception e) { handle5()} //catch unexpected error
finally{
releasSource();
}
由上面的代码可以看出部分优点:
1. 业务代码和错误处理代码分离.
2. 强制程序猿考虑程序的稳定性.
3. 有利于代码调试(异常信息)
4. 即使任何异常产生, 能保证占用的释放(finally)
1. 异常嵌套难免影响代码可读性
2. 并不能令程序逻辑更加清晰.
3. 异常并不能解决所有问题
文章浏览阅读2.4k次。其他 NAS 型号,可以于下载中心查询是否支援 Synology Drive Server 套件。_ds212j管理
文章浏览阅读1.4k次。Weka新手文章(一) 收藏数据仓库,数据分析,不涉及商业方面的高层决策之用,故本篇文章只适合初学数据仓库,为了完成老师作业,且想用weka做简单数据挖掘之用的童鞋。weka版本是3.6.2,数据库库是SQL Server 2005,没办法,老师提供的几万条数据保存在excel表中,如果从excel转为csv格式,再从weka中导入该csv文件,涉及到格式的转换,很是麻烦~况且几万条数_cannot resolve weka:weka:3.6.2
文章浏览阅读1.2k次。电子标签的概念电子标签的概念二、RFID电子标签的分类:三、RFID标签的原理四、RFID标签的组成五、RFID的工作原理阅读器和电子标签之间的射频信号的耦合类型有两种:电感耦合电磁反向散射耦合六、RFID电子标签的数据存储七、RFID低频简介八、RFID高频简介九、RFID超高频简介十、RFID微波段简介RFID电子标签的防冲撞机制面向比特的防冲突机制面向时隙的防冲突机制总结)电子标签的概念电子标签又称射频标签、应答器、数据载体;是一种存储数据识别资料的装置,可以透过无线电波与读写器之间互相传递_rfid防冲突机制
文章浏览阅读1.6k次,点赞2次,收藏4次。注意:以下方法是我通过多方查找摸索拼凑出来的出来的,可能和某些书籍或博主给出的不同; 亲测能自动播放音乐,但不知道什么缘故只我再测试时只有360极速游览器可以用。 由于没开网站,效果可以自己试试(很简陋)1:代码如下:<!DOCTYPE html><html><head> <meta charset="UTF-8"> <title>歌曲</title> <style type="text/css"&g.._sublime音乐播放器代码
文章浏览阅读8.8k次,点赞3次,收藏7次。抽个中午的时间写一篇博客,想必大家现在正在午饭呢吧,深圳的天气真是变换无常,刚刚大雨倾盆,不一会就晴天高照。打球吗?约起来哇,哈哈。。今天给大家带来一篇Dialog提示附加动画效果的功能。这种Dialog提示效果基本变成了每个App都必不可少功能。例如,退出提示,弹出分享框,App升级提示等等。。其实在Android中实现提示功能由很多种方式:自定义Dialog,AlertDialog,自_android dialog 动画右出出入效果
文章浏览阅读432次。tff.learning 模块用于使用联合学习算法的模型开发的公共API模块framework模块:面向开发联合学习算法的贡献者的公共API类BatchOutput类: 保存tf .learning. model输出的结构。Model类: 表示TensorFlow联邦中使用的模型。TrainableModel类: 带有用..._tff.learning.build_federated_averaging_process
文章浏览阅读1.7k次,点赞2次,收藏3次。最近在部署一个springboot的war文件到tomcat的时候,出现了一大堆的404,找不到的问题,在eclipse调试中不曾出现。后来仔细核实发现,原来确实是路径有问题。在浏览器可以看见他的后台访问路径如下:XHR POST http://127.0.0.1:8080/home/welcome //这是一个mapping映射,到controller......_war包 静态资源必须放入 classes文件夹才能被访问到
文章浏览阅读202次。一. 首先开启Windows功能在这里把你需要的服务都选中,如果你不清楚具体需要哪些,不妨全部选中。二. 进入IIS管理器三. 建站把你的网站资源和文件存到一个合适的位置,为了测试我们只用最简单的示范(稍微正经一点的网页也不会像我这么写...)。<html><body><h1>My IIS Test Page</h1></body></html>..._iis搭建网站的基本原理
文章浏览阅读9.5k次,点赞4次,收藏9次。pandas提供基于行和列的聚合操作,groupby可理解为是基于行的,agg则是基于列的从实现上看,groupby返回的是一个DataFrameGroupBy结构,这个结构必须调用聚合函数(如sum)之后,才会得到结构为Series的数据结果。 而agg是DataFrame的直接方法,返回的也是一个DataFrame。当然,很多功能用sum、mean等等也可以实现。但是agg更加简洁, 而..._pandas group by agg
文章浏览阅读4.1k次,点赞3次,收藏25次。使用onchange事件,当点击不同下拉框选项时,改变div背景颜色以及文字效果展示代码演示<!DOCTYPE html><html> <head lang="en"> <meta charset="UTF-8"> <title>onchange()</title> <style type="text/css"> #div { width: 300px; height_js select>option鼠标滑动背景色设置
文章浏览阅读2.4k次。一、计算机基础知识,Java语言的概述,运行环境及开发工具的下载安装1、计算机基础知识1.1、计算机的概念什么是计算机:(Computer)全称:电子计算机,俗称电脑。是一种能够按照程序运行,自动、高速处理数据的现代化智能电子设备。由硬件和软件所组成,没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机。按照规模分为微型机、小型机、大型机、巨型机(超级计算机)等。1.2、计算机的组成计算机组成大致由“计算机硬件”和“计算机软件”组成①、计算机硬件:计算机硬件(Computer_计算机中数据的分类
文章浏览阅读1.5k次。快速导入和导出DWG,DXF,JPG,3DS格式文件,实现方案构思,效果图与施工图绘制的完美结合。专业用于 3D 建模,设计,创建和交流建筑,施工,工程等方面的创意。方便的推拉功能,设计师通过一个图形就可以方便的生成3D几何体,无需进行复杂的三维建模。适用范围广阔,可以应用在建筑,规划,园林,景观,室内以及工业设计等领域。具有草稿,线稿,透视,渲染等不同显示模式。_sketchup_pro2023 m1