java 第六讲 Exception
Java异常（Exception）处理以及常见异常总结
Java异常（Exception）处理以及常见异常总结⽬录前⾔异常简介异常类型总结前⾔很多事件并⾮总是按照⼈们⾃⼰设计意愿顺利发展的，经常出现这样那样的异常情况。
例如：你计划周末郊游，计划从家⾥出发→到达⽬的→游泳→烧烤→回家。
但天有不测风云，当你准备烧烤时候突然天降⼤⾬，只能终⽌郊游提前回家。
“天降⼤⾬”是⼀种异常情况，你的计划应该考虑到这样的情况，并且应该有处理这种异常的预案。
计算机程序的编写也需要考虑处理这些异常情况。
异常（exception）是在运⾏程序时产⽣的⼀种异常情况，已经成为了衡量⼀门语⾔是否成熟的标准之⼀。
⽬前的主流编程语⾔java也提供了异常处理机制。
异常简介Java中的异常⼜称为例外，是⼀个在程序执⾏期间发⽣的事件，它中断正在执⾏程序的正常指令流。
为了能够及时有效地处理程序中的运⾏错误，必须使⽤异常类，这可以让程序具有极好的容错性且更加健壮。
在 Java 中⼀个异常的产⽣，主要有如下三种原因：1. Java 内部错误发⽣异常，Java 虚拟机产⽣的异常。
2. 编写的程序代码中的错误所产⽣的异常，例如空指针异常、数组越界异常等。
3. 通过 throw 语句⼿动⽣成的异常，⼀般⽤来告知该⽅法的调⽤者⼀些必要信息。
Java 通过⾯向对象的⽅法来处理异常。
在⼀个⽅法的运⾏过程中，如果发⽣了异常，则这个⽅法会产⽣代表该异常的⼀个对象，并把它交给运⾏时的系统，运⾏时系统寻找相应的代码来处理这⼀异常。
我们把⽣成异常对象，并把它提交给运⾏时系统的过程称为拋出（throw）异常。
运⾏时系统在⽅法的调⽤栈中查找，直到找到能够处理该类型异常的对象，这⼀个过程称为捕获（catch）异常。
例 1为了更好地理解什么是异常，下⾯来看⼀段⾮常简单的 Java 程序。
下⾯的⽰例代码实现了允许⽤户输⼊ 1~3 以内的整数，其他情况提⽰输⼊错误。
package io.renren.config;import java.util.Scanner;/*** Created by LiYangYong*/public class TestException {public static void main(String[] args) {System.out.println("请输⼊您的选择：（1~3 之间的整数）");Scanner input = new Scanner(System.in);int num = input.nextInt();switch (num) {case 1:System.out.println("one");break;case 2:System.out.println("two");break;case 3:System.out.println("three");break;default:System.out.println("error");break;}}}正常情况下，⽤户会按照系统的提⽰输⼊ 1~3 之间的数字。
exception方法
exception方法
Java中的异常是面向对象的一个概念，通过它可以处理运行时产生
的错误和异常状态。
它可以在运行过程中检测错误和异常，并采取必要的
措施来处理它们，这样就不会产生负面影响。
一般来说，Java的异常操作可以分为两类：可检查异常和运行时异常。
可检查异常必须捕获并处理，以保证程序的正常运行，而运行时异常
只需要在触发时出现提示信息即可。
当发生异常时，第一步要做的就是捕获它，这样才能确定异常的类型，从而根据不同的异常类型采取不同的处理方式。
Java中有两种捕获异常
的方式，一种是使用try-catch语句，另一种是使用throws关键字。
try-catch语句用于捕获异常并处理异常。
它有两个语句块，第一个
是try语句块，用于放置可能出现异常的代码，第二个是catch语句块，
用于捕获抛出的异常，同时可以对该异常进行处理。
另一种捕获异常的方法就是使用throws关键字。
throws关键字可以
将可抛出的异常（即可检查异常）声明在方法名称之后，这样，调用方法
的程序就需要创建try-catch块来捕获这些异常。
如果没有使用try-
catch块捕获这些异常，则会调用throws子句声明的方法的调用者捕获
该异常。
如果发生运行时异常，则不需要捕获此异常，因为在程序运行过程中，运行时异常是不能被捕获的。
JAVA讲义第6章
第6章 Java 异常处理6.1错误。
在不支持异常处理的计算机语言中，错误必须被人工进行检查和处理，这显然麻烦而低效。
Java 语言提供了异常处理机制，为方法的异常终止和出错处理提供了清楚的接口。
异常（exception ）也是异常事件（exceptional event ）的简称，它是在程序运行中出现的违背指定正常流向的事件。
许多不同种类的错误可以导致异常，从严重的硬件错误到简单的编程错误。
当在Java 方法中发生这样的错误时，方法将创建一个异常对象，并把它交给运行系统处理，运行系统负责找到处理错误的代码并执行之。
异常对象包括关于异常的信息、类型和错误发生时程序的状态以及对该错误的详细描述。
在Java 中，创建一个异常对象并把它送到运行系统叫做抛出异常。
在抛出异常后，运行系统将寻找合适的方法来处理异常。
如果产生的异常类与所处理的异常类一致，则认为找到了合适的异常处理方法。
如果运行系统找遍了所有方法而没有找到合理的异常处理方法，则运行系统将终止Java 程序的运行。
异常处理也叫做捕捉异常。
Java 中的每个异常都是一个对象，它是ng 包中Throwable 类或其子类的实例对象。
Throwable 类有两个子类：Exception 类和Error 类。
Exception 类是可以被捕捉并且可能恢复的异常类，也可以继承Exception 类生成自己的异常类。
Error 类一般被认为是不可恢复和不可捕捉的异常类。
6.2java 语言用继承的方式来组织各种异常。
所有的异常都是Throwable 类或子类，而Throwable 类又直接继承于object 类。
Throwable 类有两个子类：Error 类与Exception 类。
Exception 类又进一步细分为RuntimeException （运行异常）类和Non-RuntimeException （非运行异常）类。
图6.1显示了各异常之间的继承关系。
Java——异常（Exception）
Java——异常（Exception）A.1. 异常分类所有异常都是由Throwable继承⽽来，但在下⼀层⽴即分解为两个分⽀：Error和Exception Error异常：该层次异常描述了系统运⾏时内部错误和资源耗尽错误。
应⽤程序不该抛出这种类型的对象，如果出现这种错误，除了通告给⽤户，并尽⼒使程序安全推出，再也⽆能为了。
这种情况很少出现。
Exception异常：该层次异常⼜分解为两个分⽀，⼀个派⽣于RuntimeException；另⼀个分⽀包含其他异常。
划分为两个分⽀的规则是：由程序错误导致的异常属于RuntimeException；⽽程序本⾝没问题，但是由于像I/O错误这类问题导致的异常属于其他异常。
Java语⾔规范将派⽣于Error类或RuntimeException类的所有异常称为⾮受(unchecked)查异常，所有其他的异常称为受查(checked)异常。
2. 声明受查异常下⾯四种情况应该抛出异常：1. 调⽤⼀个抛出受查异常的⽅法，例如，FileInputStream构造器。
2. 程序运⾏过程中发现错误，并且利⽤throw语句抛出⼀个受查异常。
3. 程序出现错误。
4. java虚拟机的运⾏时库出现的内部错误。
如果出现前两种情况之⼀，则必须告诉调⽤这个⽅法的程序员有可能抛出异常。
ss对于那些可能被别⼈使⽤的java⽅法，应该根域异常规范，在⽅法的⾸部声明这个⽅法可能抛出的异常。
如果有可能抛出多个异常，应该逗号分开例如：throws FileNotFoundException,EOFException但是不需要声明Error错误，任何程序都有抛出那些异常的潜能，⽽我们对其没有任何控制能⼒。
同样也不该声明从RuntimeException继承的那些⾮受查异常。
警告：如果在⼦类中覆盖了超类的⼀个⽅法，⼦类⽅法中声明的受查异常不能⽐超类⽅法中声明的异常更通⽤（也就是说，⼦类⽅法中可以抛出更特定的异常，或者根本不抛出任何异常）。
ExceptionJava异常的几点说明
Java---异常ng.Throwable|----Exception:程序可以处理的异常|----Error：与虚拟机相关问题，系统崩溃，虚拟机问题，内存不足，内存堆栈溢出……建议程序停止。
异常：程序在运行时出现不正常情况，java对不正常情况进行描述后的对象体现。
-------------------------------------------------常见的处理方法：|---String getMessage();|---String toString()|---void printStackTrace();(jvm默认的异常处理机制其实就是调用printStackTrace());-------------------------------------------------异常的处理：try { …}catch(异常类变量) ｛//处理几个异常就声明几个catch…（多个catch块中的异常出现继承关系时，父类catch块要放在子类catch下面）｝finally{ …}//非必须，但声明后一定会执行，一般用于释放资源Eg:数据库异常时无法关闭数据库，可使用finally，对资源的关闭例外：System.exit(0)系统退出，jvm结束，finally不执行。
------------------------------------------------异常的声明（throws）编写Demo时，代码可能发生异常通过throws声明功能可能会出现的异常：Eg: intdiv(int a ,int b)throws Exception{Return a/b;//我们知道b=0时会抛出ArithmeticException；｝public static void main(String [] args){try{ …} catch(Exception e){ …}}（catch处理时，最好要有具体的处理形式，例如异常日志文件等）-------------------------------------自定义异常：项目中会出现持有的问题，而这些问题并未被java所描述并封装对象时，可将这些问题进行自定义的异常封装（自定义类继承异常类）继承异常的原因：因为异常类和异常对象都被抛出，他们都具备可抛性，这个可抛性是Throwable体系特点，只有这个体系中的类和对象才可以被throws 和throw操作------------------------------假设：a/b中，除数如果是负数和0都认为是错的异常描述。
Java里的异常（Exception）详解
Java⾥的异常（Exception）详解作为⼀位初学者, 本屌也没有能⼒对异常谈得很深⼊. 只不过⾥关于Exception的东西实在是很多. 所以这篇⽂章很长就是了..⼀, 什么是java⾥的异常由于java是c\c++ 发展⽽来的, ⾸先我们先看看c语⾔⾥的错误.1.1 c语⾔⾥的错误我们实现1个程序的过程包括, 代码编写, 编译代码成为程序, 执⾏程序..其中⼤部分常见的语法错误都会被编译代码这样部过滤掉. 但是即使通过了编译. 执⾏程序这⼀步可能还是会有错误.原因很多, 例如常见的除数为0, 内存溢出(数组的index超出界限), 或者内存被其他程序修改等.最简单的例⼦:[java]1. #include <stdio.h>2.3. int f(int a, int b){4. return a/b;5. }6.7. int main(){8. int i = f(8,0);9. printf("i is %d\n",i);10. return 0;11. }上⾯的例⼦编译时是⽆错的, 但是⼀旦执⾏就会提⽰吐核错误了.c语⾔⾥对这种执⾏时出现的错误是⽆能为⼒的, ⼀旦出错就会整个程序崩溃, 就不会在继续执⾏下⾯的代码.⽽且很多时候出错信息很少, 让你⽆法判断出错的原因和地⽅, 只能⼀步步⼩⼼debug...所以很多⽤c写的程序有时会出现⾮法关闭的现象.解决⽅法只能是在代码⾥对可能出错的地⽅添加if 判断.例如f()函数⾥可以对b进⾏判断, 如果是0就不执⾏.1.2 java⾥运⾏时出现的错误java⾥编译器对代码的规范性⽐c严格得多. 但是即使如此, 通过编译的java程序有时也很难避免执⾏时出错.例如, 将上⾯的c程序改编成java程序:[java]1. package Exception_kng;2.3. class Exp1{4. public int f(int a, int b){5. return a/b;6. }7. }8.9. public class Expt_1{10. public static void g(){11. Exp1 e = new Exp1();12. int i = e.f(8,0);13. System.out.printf("i is %d\n", i);14. }15. }运⾏时⼀样会出错, 下⾯是出错信息:[java]1. [java] Caused by: ng.ArithmeticException: / by zero2. [java] at Exception_kng.Exp1.f(Expt_1.java:5)3. [java] at Exception_kng.Expt_1.g(Expt_1.java:12)4. [java] at Enter_1.main(Enter_1.java:31)但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与⽂件⾏数输出, ⽅便你调试. jvm虚拟机是会对错误作出⼀定的处理的.所以可以简单地将java⾥的异常理解成java运⾏时出现的错误, 异常机制就是对这种错误进⾏处理的机制.1.3 java异常的定义实际上, 当java程序执⾏时出现错误时, jvm会把执⾏时出错的信息(例如出错原因, 类型, 位置) 收集,然后打包成为1个对象(object), 程序员可以对这种对象进⾏处理. 这种对象就是所谓的异常.可能出现的异常的代码并不是肯定会出现异常, 取决于执⾏环境和数据.!⼆, java⾥的异常的分类.见下图:Throwable/ \Error Exception/ / \xxxxxx xxxxxx RuntimeException/ \xxxxxx ArithmeticException上图的所有对象都是类.Throwable 代表是可抛出的.Error 代表的是严重错误, 这种错误程序员⽆法进⾏处理, 例如操作系统崩溃, jvm出错, 动态链接库失败等. Error并不是异常, 不是本⽂的重点.Exception 代表的就是异常了. 它下⾯很多派⽣类, 其中它的派⽣类也分两种, ⼀种是RuntimeException(运⾏时异常), 其他的都是⾮运⾏时异常RuntimeException 包括除数为0, 数组下标超界等. 运⾏时异常的派⽣类有很多, 其产⽣频率较⾼. 它的派⽣类可以由程序处理或者抛给(throw) 给jvm处理. 例如上⾯的例⼦就是抛给了jvm处理, jvm把程序中断执⾏, 并把错误信息输出到终端上.⾮RuntimeExcption 这种异常属于Excepion的派⽣类(上⾯红⾊的xxx), 但是不是RuntimeException的派⽣类, 这种异常必须由程序员⼿动处理,否则不通过编译.ArithmeticExcpetion 算术异常, 它是RuntimeException的派⽣类, 所以程序员不⼿动处理也通过编译, 只不过出错时会被jvm处理.三, java⾥对异常的处理java⾥对异常的处理有三种.3.1 程序猿对有可能出现的异常使⽤try catch处理.例如我们将上⾯的例⼦改动⼀下:[java]1. package Exception_kng;2.3. class Exp2{4. public int f(int a, int b){5. int i = 0;6. try{7. i = a/b;8. }9. catch(Exception e){10. System.out.printf("Exception occurs!!\n");11. System.out.println(e.getMessage()); //print the root cause12. System.out.printf("===========================\n");13. e.printStackTrace(); //print the info of function stuck.14. }15.16. return i;17. }18. }19.20. public class Expt_2{21. public static void g(){22. Exp2 ex = new Exp2();23. int i = ex.f(8,0); //call f()24. System.out.printf("i is %d\n", i); //successfully executed25. }26. }在f()函数中对可能出现的异常的代码进⾏try catch处理后, 程序会执⾏catch⾥的代码. ⽽且不会中断整个程序, 继续执⾏try catch后⾯的代码.程序执⾏输出:[java]1. [java] Exception occurs!!2. [java] / by zero3. [java] ===========================4. [java] ng.ArithmeticException: / by zero5. [java] at Exception_kng.Exp2.f(Expt_2.java:7)6. [java] at Exception_kng.Expt_2.g(Expt_2.java:23)7. [java] at Enter_1.main(Enter_1.java:31)8. [java] i is 0注意最终也执⾏了g()函数中的最后⼀条语句, 输出了i的值.也就是说try catch处理后并不会终⽌程序, 令程序即使出现了错误, 也可以对错误进⾏⼀定的处理后继续执⾏. 这就是java异常机制⽐c语⾔安全的地⽅.下⾯会详细讲解 try catch.注:getMessage() ⽅法: Exception类的⽅法之⼀, 返回异常的原因, 上⾯的 / by zero 就是这个⽅法输出的.printStackTrace(): Exception类的⽅法之⼀, 在屏幕输出函数栈信息, 也就是异常出现的地⽅.3.2 函数⾥并不处理异常, 使⽤throw or throws 关键字把可能出现的异常抛给调⽤该函数的上级函数处理.例如我在f()函数中不想处理可能出现的异常, 想把它抛出上级函数处理:下⾯是个例⼦:[java]1. package Exception_kng;2.3. class Exp3{4. public int f(int a, int b){5. if (0 == b){6. throw new ArithmeticException("Shit !!! / by zero!");7.8. }9.10. return a/b;11. }12. }13.14. public class Expt_3{15. public static void g() throws ArithmeticException{16. Exp3 ex = new Exp3();17. int i = 22;18. i = ex.f(8,0); //throw excetpion19. System.out.printf("i is %d\n", i); //failed executed20. System.out.printf("g() is done!!\n"); //failed executed21. }22.23. public static void h(){24. try{25. g();26. }catch(ArithmeticException e){27. System.out.printf("Exception occurs!!\n");28. System.out.println(e.getMessage()); //print the root cause29. System.out.printf("===========================\n");30. e.printStackTrace(); //print the info of function stuck.31. }32.33. System.out.printf("h() is done!!\n"); //successfully executed34. }35. }可以见到f() 加了个条件判断, 如果参数b = 0, 使⽤throw 直接⼿动抛出1个异常. 让调⽤它的函数处理.g()调⽤f()函数, 预见到f()可能有异常, 但是也不想处理, 使⽤throws 关键字告诉调⽤它的函数本函数有可能抛出这种异常. // 注, 这⾥的throws 对程序并没有实质的影响.h()调⽤g(), 简单g()定义的throws, ⽤try catch在本函数进⾏处理.输出:[java]1. [java] Exception occurs!!2. [java] Shit !!! / by zero!3. [java] ===========================4. [java] ng.ArithmeticException: Shit !!! / by zero!5. [java] at Exception_kng.Exp3.f(Expt_3.java:6)6. [java] at Exception_kng.Expt_3.g(Expt_3.java:18)7. [java] at Exception_kng.Expt_3.h(Expt_3.java:25)8. [java] at Enter_1.main(Enter_1.java:31)9. [java] h() is done!!注意这个程序没有执⾏g() 最后的代码.throw 和 throws 后⾯也会详细讲解.3.3 交给jvm虚拟机处理假如上⾯的例⼦h() 也不处理怎么办? 就如1.2 的例⼦, 会抛给jvm处理.但是这种情况只适⽤于RuntimeExecption及其派⽣类.jvm怎么处理呢, 就是中断整个程序, 并把异常信息输出到屏幕上.实际上, 当java程序的1个函数抛出异常时,⾸先会检查当前函数有没有try catch处理, 如果⽆检查上⼀级函数有⽆try..catch处理....这样在函数栈⾥⼀级⼀级向上检查, 如果直⾄main函数都⽆try..catch, 则抛给jvm..项⽬中强烈建议尽量⼿动处理, 不要把异常交给jvm.四,Try catch finally 的处理机制.这⾥开始详解try catch finally了.语法是这样的.try{可能出异常的若⼲⾏代码;}catch(ExceptionName1 e){产⽣ExceptionName 1的处理代码;}catch(ExceptionName2 e){产⽣ExceptionName 2的处理代码;}...finally{⽆论如何, 最终肯定会执⾏的代码}4.1 try catch finally的执⾏路线.下⾯⽤个例⼦来说明:[java]1. try{2. f();3. ff();4. }5. catch(ArithmeticException e){6. g();7. }8. catch(IOException e){9. gg();10. }11. catch(AuthorizedException e){12. ggg();13. }14. finally{15. h();16. }17.18. k();4.1.1 当try⾥⾯的f()抛出了IOException当f()抛出了异常, 那么ff()就不会执⾏了. 程序会尝试捕捉异常.⾸先捕捉ArithmeticException, 捕捉失败.接下来捕捉IOException, 捕捉成功, 执⾏gg();⼀旦捕捉到⼀个异常, 不会再尝试捕捉其他异常, 直接执⾏finally⾥的h();执⾏后⾯的函数k().也就是说路线是:f() -> gg() -> h() -> k()有2点要注意的.1. f()函数极有可能未完整执⾏, 因为它抛出了异常, 抛出异常的语句执⾏失败, 之后的语句放弃执⾏.2. try{} ⾥⾯, f()之后的语句, 例如ff()放弃执⾏.4.1.2 没有任何异常抛出这种情况很简单, 就是try{}⾥⾯的代码被完整执⾏, 因为没有抛出任何异常, 就不会尝试执⾏catch⾥的部分, 直接到finally部分了.路线是:f() -> ff() -> h() -> k()4.2 如何确定要捕捉的异常名字.也许有⼈会问, 我们怎么知道到底会抛出什么异常?下⾯有3个解决⽅案.1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.2.在catch的括号⾥写上Exception e, 毕竟Exception 是所有其他异常的超类, 这⾥涉及多态的知识, ⾄于什么是多态可以看看本⼈的另⼀篇⽂章.3. 观察被调⽤函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常4.3 为什么需要finally包括我在内很多⼈会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执⾏, 上⾯那个例⼦⾥的h()为什么不跟下⾯的k() 写在⼀起呢.上⾯的例⼦的确看不出区别.但下⾯两种情况下就体现了finally独特的重要性.4.3.1 抛出了1个异常, 但是没有被任何catch⼦句捕捉成功.例如try⾥⾯抛出了1个A异常, 但是只有后⾯只有捕捉B异常, 和C异常的⼦句.这种情况下, 程序直接执⾏finally{}⾥的⼦句, 然后中断当前函数, 把异常抛给上⼀级函数, 所以当前函数finally后⾯的语句不会被执⾏.例⼦:[java]1. package Exception_kng;2.3. import .*;4. import java.io.*;5.6. class Exp4{7. public int f(int a, int b) throws IOException, BindException{8. return a/b;9. }10. }11.12. public class Expt_4{13. public static void g(){14. Exp4 ex = new Exp4();15. int i = 22;16. try{17. System.out.printf("g() : try!!\n"); //failed18. i = ex.f(8,0); //call f()19. }20. catch(BindException e){21. System.out.printf("g() : BindException!!\n"); //failed22. }23. catch(IOException e){24. System.out.printf("g() : IOException!!\n"); //failed25. }26. finally{27. System.out.printf("g() : finaly!!\n"); //successfully executed28. }29. System.out.printf("g() is done!!\n"); //failed30. }31.32. public static void h(){33. try{34. g();35. }catch(ArithmeticException e){36. System.out.printf("Exception occurs!!\n");37. System.out.println(e.getMessage()); //print the root cause38. System.out.printf("===========================\n");39. e.printStackTrace(); //print the info of function stuck.40. }41.42. System.out.printf("h() is done!!\n"); //successfully executed43. }44. }我所说的情况, 就在上⾯例⼦⾥的g()函数, g()函数⾥尝试捕捉两个异常, 但是抛出了第3个异常(ArithmeticException 算术异常).所以这个异常会中断g()的执⾏, 因为没有被捕捉到, 然后抛给调⽤g()的 h()函数处理, ⽽在h()捕捉到了, 所以h()函数是能完整执⾏的.也就是说g()⾥的[java]1. System.out.printf("g() is done!!\n"); //failed执⾏失败⽽h()⾥的[java]1. System.out.printf("h() is done!!\n"); //successfully executed执⾏成功但是⽆论如何, g()⾥的finally{}部分还是被执⾏了执⾏结果如下:[java]1. [java] g() : try!!2. [java] g() : finaly!!3. [java] Exception occurs!!4. [java] / by zero5. [java] ===========================6. [java] ng.ArithmeticException: / by zero7. [java] at Exception_kng.Exp4.f(Expt_4.java:8)8. [java] at Exception_kng.Expt_4.g(Expt_4.java:18)9. [java] at Exception_kng.Expt_4.h(Expt_4.java:34)10. [java] at Enter_1.main(Enter_1.java:31)11. [java] h() is done!!这种情况是1中编程的低级错误, 在项⽬中是不允许出现.避免⽅法也⼗分简单, 在catch⼦句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.4.3.2 在catch⼦句内有return⼦句.下⾯例⼦:[java]1. try{2. f();3. ff();4. }5. catch(ArithException e){6. g();7. return j();8. }9. catch(IOException e){10. gg();11. return j();12. }13. catch(AuthorizedException e){14. ggg();15. return j();16. }17. finally{18. h();19. }20.21. k();假如在f()函数抛出了IOExcepion 异常被捕捉到.那么执⾏路线就是f() -> gg() -> j() -> h() -> 上⼀级function也就说, 这种情况下finally⾥的⼦句会在return回上⼀级function前执⾏. ⽽后⾯的k()就被放弃了.4.3.3 finally作⽤⼩结.可以看出, finally⾥的语句, ⽆论如何都会被执⾏.⾄有两种情况除外, ⼀是断电, ⼆是exit函数.在项⽬中, 我们⼀般在finally编写⼀些释放资源的动作, 例如初始化公共变量. 关闭connections, 关闭⽂件等.4.4 try catch finally⾥⼀些要注意的问题.4.4.1 ⽆论如何最多只有1个catch被执⾏这个上⾯提到过了, ⼀旦捕捉到1个异常, 就不会尝试捕捉其他异常.如果try⾥⾯的⼀段代码可能抛出3种异常A B C,⾸先看它先抛出哪个异常, 如果先抛出A, 如果捕捉到A, 那么就执⾏catch(A)⾥的代码. 然后finally.. B和C就没有机会再抛出了.如果捕捉不到A, 就执⾏finally{}⾥的语句后中断当前函数, 抛给上⼀级函数...(应该避免)4.4.2 有可能所有catch都没有被执⾏两种情况, 1就是没有异常抛出, 另⼀种就是抛出了异常但是没有捕捉不到(应该避免)4.4.3 先捕捉⼦类异常, 再捕捉⽗类异常, 否则编译失败加⼊try ⾥⾯尝试捕捉两个异常, 1个是A, 1个是B, 但是A是B的⽗类.这种情况下, 应该把catch(B)写在catch(A)前⾯.原因也很简单, 加⼊把catch(A)写在前⾯, 因为多态的存在, 即使抛出了B异常, 也会被catch(A)捕捉, 后⾯的catch(B)就没有意义了.也就是说如果捕捉Exception这个异常基类, 应该放在最后的catch⾥, 项⽬中也强烈建议这么做, 可以避免上述4.3.1的情况出现.4.4.4 catch与catch之间不能有任何代码.这个没什么好说的. 语法规则4.4.5 finally⾥不能访问catch⾥捕捉的异常对象e每1个异常对象只能由catch它的catch⼦句⾥访问.4.4.6 try⾥⾯的定义变量不能在try外⾯使⽤.跟if类似, 不多说了.4.4.7 try catch finally可以嵌套使⽤.这个也不难理解..五, throw 和throws的机制和⽤法.下⾯开始详讲异常另⼀种处理⽅法throw 和 throws了.注意的是, 这两种⽤法都没有真正的处理异常, 真正处理的异常⽅法只有try catch, 这两种⽅法只是交给上⼀级⽅法处理.就如⼀个组织⾥ , 有1个⼤佬, 1个党主, 1个⼩弟.⼤佬叫党主⼲活, 堂主叫⼩弟⼲活, 然后⼩弟碰上⿇烦了, 但是⼩弟不会处理这个⿇烦, 只能中断⼯作抛给党主处理, 然后堂主发现这个⿇烦只有⼤佬能处理, 然后抛给⼤佬处理..道理是相通的..5.1 throw 的语法与作⽤throws的语法很简单.语法:throw new XException();其中xException必须是Exception的派⽣类.这⾥注意throw 出的是1个异常对象, 所以new不能省略作⽤就是⼿动令程序抛出1个异常对象.5.2 throw 1个 RuntimeException及其派⽣类我们看回上⾯3.2 的例⼦:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new ArithmeticException("Shit !!! / by zero!");4.5. }6.7. return a/b;8. }5.2.1 throw会中断当前函数, 当前函数执⾏失败(不完整)当这个函数的if 判断了b=0时, 就利⽤throws⼿动抛出了1个异常. 这个异常会中断这个函数. 也就是说f()执⾏不完整, 是没有返回值的.5.2.2, 接下来哪个调⽤这个函数就会在调⽤这个函数的语句上收到异常.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k();6. }例如上没的g()函数, 在调⽤f() 会收到1个异常.这时g()函数有三种选择.1. 不做任何处理这时, g()收到f()⾥抛出的异常就会打断g()执⾏, 也就是说g()⾥⾯的k(); 被放弃了, 然后程序会继续把这个函数抛给调⽤g()函数.然后⼀级⼀级寻求处理, 如果都不处理, 则抛给jvm处理. jvm会中断程序, 输出异常信息. 这个上没提到过了.2. 使⽤try catch处理如果catch成功, 则g()函数能完整执⾏, ⽽且这个异常不会继续向上抛.如果catch失败(尽量避免), 则跟情况1相同.5.3 throw 1个⾮RuntimeException派⽣类的异常将上⾯的例⼦改⼀下:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }例如, 我不想抛出ArithmeticException, 我想抛出IOExcetpion.注意这⾥, IOException虽然逻辑上是错误的(完全不是IO的问题嘛), 但是在程序中完全可⾏, 因为程序猿可以根据需要控制程序指定抛出任何1个异常.但是这段代码编译失败, 因为IOException 不是 RuntimeException的派⽣类.java规定:5.3.1 如果⼀个⽅法⾥利⽤throw⼿动抛出1个⾮RuntimeException异常, 必须在函数定义声明⾥加上throws 后缀改成这样就正确了:[java]1. public int f(int a, int b) throws IOException{2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }注意在⽅法定义⾥加上了throws⼦句. 告诉调⽤它的函数我可能抛出这个异常.5.3.2 调⽤该⽅法的⽅法则必须处理这个异常例如抄回上⾯的例⼦, g()调⽤f()函数.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k()6. }但是编译失败.因为f()利⽤throws 声明了会抛出1个⾮runtimeExcetpion. 这时g()必须做出处理.处理⽅法有两种:1. try catch⾃⼰处理:[java]1. public void g(){2. int i = 0;3. h();4. try{5. i = f(); //recevie excepton6. }7. catch(IOException e){8.9. }10. k();11. }需要注意的是, catch⾥⾯要么写上throws对应的异常(这⾥是 IOException), 要么写上这个异常的超类, 否则还是编译失败.2.g()利⽤throws 往上⼀级⽅法抛.[java]1. public void g() throws IOException{2. int i = 0;3. h();4. i = f(); //recevie excepton5. k();6. }这是调⽤g()的函数也要考虑上⾯的这两种处理⽅法了...但是最终上级的⽅法(main ⽅法)还是不处理的话, 就编译失败, 上⾯说过了, ⾮runtimeException⽆法抛给jvm处理.虽然这两种处理⽅法都能通过编译, 但是运⾏效果是完全不同的.第⼀种, g()能完整执⾏.第⼆种, g()被中断, 也就是g()⾥⾯的k(); 执⾏失败.5.4 throws 的语法.throws稍微⽐throw难理解点:语法是:public void f() throws Exception1, Exception2...{}也就是讲, thorws可以加上多个异常, 注意这⾥抛出的不是对象, 不能加上new.⽽且不是告诉别⼈这个函数有可能抛出这么多个异常. ⽽是告诉别⼈, 有可能抛出这些异常的其中⼀种.5.5 throws 的作⽤.如果为f()函数加上throws后续, 则告诉调⽤f()的⽅法, f()函数有可能抛出这些异常的⼀种.如果f()throws 了1个或若⼲个⾮RuntimeException, 则调⽤f()的函数必须处理这些⾮RuntimeException, 如上⾯的g()函数⼀样.如果f() throws的都是RuntimeException, 则调⽤f()的函数可以不处理, 也能通过编译, 但是实际上还是强烈建议处理它们.实际上, 如果1个⽅法f() throws A,B那么它有可能不抛出任何异常.(程序运⾏状态良好)也有能抛出C异常(应该避免, 最好在throws上加上C)5.6 什么时候应该⽤throws5.6.1 ⼀个函数体⾥⾯⼿动throw了1个RumtimeException, 则这个函数的定义必须加上throws⼦句这个是强制, 告诉别⼈这个函数内有炸弹.5.6.2 ⼀个函数内有可能由系统抛出异常.这个是⾮强制的, 但是如果你知道⼀个函数内的代码有可能抛出异常, 最好还是写上throws 后缀⽆论这个异常是否runtimeExcepion.5.7 ⼀般情况下,调⽤1个带有throws⽅法时怎么办个⼈建议, 如果你调⽤1个函数throws A, B, C那么你就在当前函数写上catch(A)catch(B)catch(C)catch(Exception)这样能处理能保证你的函数能完整执⾏, 不会被收到的异常中断.当然如果你允许你的函数可以被中断, 那么就可以在当前函数定义加上throws A, B 继续抛给上⼀级的函数.5.8 重写⽅法时, throws的范围不能⼤于超类的对应⽅法.例如你在⼀个派⽣类重写⼀个⽅法f(), 在超类⾥的f() throws A, B 你重写⽅法时就不throws出 A,,B,C 或者throws A和B的超类.原因也是由于多态的存在.因为1个超类的引⽤可以指向1个派⽣类的对象并调⽤不同的⽅法. 如果派⽣类throws的范围加⼤那么利⽤多态写的代码的try catch就不再适⽤.六, throw和throws⼀些主要区别.⾯试问得多,单独拉出来写了:6.1 throw 写在函数体内, throws写在函数定义语句中.应付⾯试官.6.2 throw 是抛出1个异常对象, throws是有能抛出异常的种类所以throw后⾯的⼀般加上new 和exception名字().⽽throws后⾯不能加上new的6.3 ⼀个⽅法最多只能throw1个异常, 但是可以throws多个种类异常因为⼀旦⼀个函数throw出1个异常, 这个函数就会被中断执⾏, 后⾯的代码被放弃, 如果你尝试在函数内写两个throw, 编译失败.⽽throws 是告诉别⼈这个函数有可能抛出这⼏种异常的⼀种. 但是最多只会抛出⼀种.6.4 如果在⼀个函数体内throw 1个⾮runtimeException, 那么必须在函数定义上加上throws后缀. 但反过来就不是必须的.原因上⾯讲过了.七, ⾃定义异常.我们可以⾃定义异常, 只需要编写1个类, 继承1个异常类就ok例⼦:[java]1. package Exception_kng;2.3. class User_Exception1 extends ArithmeticException{4. public User_Exception1(String Exception_name){5. super(Exception_name);6. }7.8. public void printStackTrace(){ //overwrite9. super.printStackTrace();10. System.out.printf("hey man, i am an user_defined excetpion\n");11. }12. }13.14. class Exp6{15. public int f(int a, int b){16. if (0 == b){17. throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception18. }19.20. return a/b;21. }22. }23.24. public class Expt_6{25. public static void g() {26. Exp6 ex = new Exp6();27. int i = 22;28. try{29. i = ex.f(8,0); //throw excetpion30. }catch(User_Exception1 e){31. e.printStackTrace();32. }33. System.out.printf("i is %d\n", i);34. System.out.printf("g() is done!!\n");35. }36. }上⾯的类User_Exception1 就是1个⾃定义异常, 并重写了printStackTrace()⽅法.⼋,java异常的优缺点.8.1 c语⾔是如何处理程序错误的.我们要理解异常的优缺点, ⾸先看看没有异常的是如何处理错误的.下⾯是个例⼦:[cpp]1. //openfile2. if (fileOpen() > 0){3. //check the length of the file4. if (gotLengthOfTheFile() > 0){5. //check the memory6. if (gotEnoughMemory() > 0){7. //load file to memory8. if (loadFileToMem() > 0){9. readFile();10. }else{11. errorCode = -5;12. }13.14. }else{15. errorCode = -5;16. }17.18. }else{19. errorCode = -5;20. }21.22. }else{23. errorCode = -5;24. }25.26. //handle error27. case errorCode....28.29. //release Source30. releaseSource();可以见到处理错误有这些特点1. ⼤部分精⼒都在错误处理.2. 需要把各种可能出现的错误全部考虑到, 才能保证程序的稳定性.3. 程序可读性差, 错误处理代码混杂在其他代码中.4. 出错返回信息少, ⼀旦出错难以调试.5. ⼀旦出现了未考虑到的错误, 资源释放代码⽆法执⾏.8.2 java异常机制下是如何编写上述代码的.[java]1. try{2. fileOpen();3. gotLengthOfTheFile();4. gotEnoughMemory();5. loadFileToMem();6. readFile();7. }8. catch(fileOpenFail) { handle1()}9. catch(gotLengthOfTheFileFail) { handle2()}10. catch(gotEnoughMemoryFail) { handle3()}11. catch(loadFileToMemFail) { handle4()}12. catch(readFileFail) { handle4()}13. catch(Exception e) { handle5()} //catch unexpected error14. finally{15. releasSource();16. }8.3 java异常机制的优点:由上⾯的代码可以看出部分优点:1. 业务代码和错误处理代码分离.2. 强制程序猿考虑程序的稳定性.3. 有利于代码调试(异常信息)4. 即使任何异常产⽣, 能保证占⽤的释放(finally)8.4 java异常机制的缺点:1. 异常嵌套难免影响代码可读性2. 并不能令程序逻辑更加清晰.3. 异常并不能解决所有问题。
exception的用法
exception的用法异常（Exception）是在程序运行过程中发生的错误或异常情况。
在编程中使用异常处理机制可以使程序具备更好的容错性和可靠性。
本文将围绕异常的用法展开，包括异常的定义、异常的分类、异常处理的基本语法以及异常处理的最佳实践等方面进行一步一步的回答。
一、异常的定义异常是指在程序运行过程中发生的错误或异常情况。
它可能是由于程序逻辑的错误、外部环境的变化或用户输入的不合法等原因引起的。
例如，当除数为零时，产生一个除以零的异常。
二、异常的分类在Java中，异常被分为两类：检查异常（Checked Exception）和非检查异常（Unchecked Exception）。
检查异常是指在编译时就需要处理的异常，必须显式地进行捕获或声明抛出。
非检查异常则是在运行时才会被检测到的异常，可以选择是否进行处理。
1. 检查异常检查异常是Exception类及其子类的实例。
它们通常是预料到的、需要处理的异常情况。
如果不处理这些异常，程序将无法通过编译。
2. 非检查异常非检查异常是RuntimeException类及其子类的实例。
它们通常是由程序代码的错误引起的，如空指针异常（NullPointerException）或数组下标越界异常（ArrayIndexOutOfBoundsException）。
这类异常在编译时不需要进行强制处理，但在运行时会导致程序异常终止。
三、异常处理的基本语法异常处理是通过使用try-catch语句块来实现的。
基本语法如下：try {可能会引发异常的代码块} catch (ExceptionType1 e1) {处理ExceptionType1类型的异常} catch (ExceptionType2 e2) {处理ExceptionType2类型的异常} finally {可选的finally块，无论是否发生异常都会被执行}在try块中，我们编写可能会引发异常的代码。
如果发生异常，程序将跳转到对应的catch块，并进行相应的异常处理。
Java基础-异常（Exception）处理
Java基础-异常（Exception）处理 Java基础-异常（Exception）处理 作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。
⼀.异常的概述 什么是异常？Java代码在运⾏时期发⽣的问题就是异常。
在Java中，把异常信息封装成了⼀个类。
当出现了问题时，就会创建异常类对象，并抛出异常相关信息（如异常信息出现的位置，原因等）。
⼆.异常的继承体系 在Java中使⽤Exception类来描述异常。
Exception类及其⼦类是Throwable的⼀种形式，它指出了合理应⽤程序想要捕获的异常条件。
查看Java的API⽂档我们可以发现Exception有继承关系，它的⽗类是Throwable。
Throwable是Java语⾔中所有错误或异常的超类。
另外，在异常Exception类中，有⼀个⼦类要特殊说明⼀下，RuntimeException⼦类，RuntimeException及其它的⼦类只能在Java程序运⾏过程中出现。
我们再来观察Throwable类，能够发现与异常Exception平级的有⼀个Error，它是Throwable的⼦类，它⽤来表⽰Java程序中可能会产⽣的严重错误。
解决办法只有⼀个，修改代码避免Error错误的产⽣。
下⾯是⼀个Error异常的案例： 综上所述，异常继承体系可以⼤致做以下简要分类，此处并未列出全部的异常，请以Java的API⽂档为标准，下图只是为了⽅便记忆：三.异常对象的产⽣原因和处理⽅式 我们看见上⾯的代码是有异常抛出的，那么异常究竟是怎么抛出的呢？其实他⼤致分为以下⼏个步骤：1>.JVM检测到异常 通过上⾯的学习，我们知道异常的祖宗其实就是Throwable类，在这个类下⾯很多个⼦类已经提前定义好了。
在代码运⾏的时候，JVM是完全有能⼒检测到出现的异常信息（⽐如：ArrayIndexOutOfBoundsException）。
2>.JVM创建异常对象 当JVM虚拟机检测到异常后，⾸先会创建异常对象（⽐如：new ng.ArrayIndexOutOfBoundsException: 5）。
java中的异常（Exception）
java中的异常（Exception）基本概念将程序执⾏中发⽣的不正常的情况称为“异常”。
开发中的语法错误和逻辑错误不是异常执⾏过程中的异常事件可分为两⼤类错误(Error)：Java虚拟机⽆法解决的严重问题。
例如：JVM系统内存错误，资源耗尽等严重问题Exception：其他因为编程错误或偶尔的外在因素导致的⼀般性可以针对不同的代码进⾏处理Exection有(编译异常[编译时，编译器查找出的异常]和运⾏异常[开发时，运⾏时])异常体系图异常体系图总结⼀般分为两⼤类，⼀种是编译时异常，⼀种是运⾏时异常运⾏时异常编译器检查不出来。
⼀般是指编译时逻辑错误，是程序员应该避免其异常对于运⾏时异常可以不做处理，因为这类异常很普遍，若全处理可能会对程序的可读性，运⾏效率产⽣影响编译时异常，是编译器要求必须处理的异常常见的运⾏时异常Null Pointer Exception 空指针异常：指还没有创建对象就想使⽤，会抛出空指针异常，当应⽤程序在需要对象的地⽅使⽤null时，会抛出异常Airthmetic Exception 数学运算异常：会出现异常的运算条件时抛出异常。
例如⼀个整数除零时会抛出异常ArrayIndex OutOfBounds Exception 数组下标越界异常：数组下标越界异常，⽤⾮法索引访问数组时抛出异常。
如果索引为负或⼤于等于数组⼤⼩则所因为⾮法索引。
Class cast Excetion 类型转换异常：当试图将对象强制转换为不是实例的⼦类时，会抛出异常Number Format Excetion 数字格式不正确异常：当应⽤程序试图将字符串转成⼀种数值类型，但该字符串不能转换为适当格式，抛出异常编译异常编译异常就是指编译阶段，就必须处理的异常，否则代码不能通过编译常见的编译异常异常处理异常处理就是在异常发⽣时，对异常处理的⽅式异常处理的⽅式理解try-catch-finally 执⾏顺序⼩结throws 异常处理throws和throw的区别。
exception类继承关系
exception类继承关系Exception类是Java编程语言中的一个基本类，它是所有异常类的父类。
在Java中，异常被分为两种类型：检查异常（Checked Exception）和非检查异常（Unchecked Exception）。
本文将以"exception类继承关系"为主题，详细解释Exception类在Java异常处理机制中的角色和其子类的继承关系。
首先，我们先来了解一下Java的异常处理机制。
在编写程序时，我们无法避免出现错误或异常情况，比如文件不存在、除数为零等等。
为了让程序更加健壮和可靠，Java提供了异常处理机制来捕获并处理这些异常情况。
异常处理机制可以让我们优雅地处理程序中的错误情况，并提供了异常处理代码的执行流程控制。
在Java中，异常由Throwable类及其子类派生而来。
Throwable类是所有异常类和错误类的超类。
Exception类是Throwable的子类，它代表了一种通常可以恢复并进行处理的异常情况。
在Exception类中，又有两个子类：RuntimeException和IOException。
RuntimeException类是非检查异常的父类。
非检查异常（Unchecked Exception）指的是在编译时不需要强制捕获或声明的异常。
通常，非检查异常是由程序逻辑错误引起的，如数组越界、空指针引用等。
这些异常是在程序运行时才会出现，并且它们的出现通常是由于代码的错误造成的。
当程序出现非检查异常时，可以选择捕获并处理，也可以交由JVM进行处理。
RuntimeException类及其子类包括常见的异常类型，如NullPointerException、IndexOutOfBoundsException等。
IOException类则是检查异常的父类。
检查异常（Checked Exception）指的是在编译时强制要求处理的异常。
这些异常可能是由外部因素引起的，如文件读取、网络连接等。
java基础异常Exception代码讲解总结
java基础异常Exception代码讲解总结Java中的Exception1异常相关概述1.1 什么是异常异常就是Java程序在运⾏过程中出现的错误。
前⾯接触过的空指针，数组越界，类型转换错误异常等1.2 ThrowableThrowable 类是Java 语⾔中所有错误或异常的超类。
只有当对象是此类（或其⼦类之⼀）的实例时，才能通过JVM 或者throw 语句抛出。
1.3异常的继承体系1.3 JVM默认是如何处理异常的?jvm有⼀个默认的异常处理机制,就将该异常的名称、异常的信息、异常出现的位置打印在了控制台上,同时程序停⽌运⾏。
1.4 Java处理异常的两种⽅式Java虚拟机处理⾃⼰处理1.5 为什么会有异常因为你不知道未来会怎么样，需要做个准备（写代码也是，你需要对⼀些未知的东西做下处理），⽐如你去旅游，不知道会下⾬还是出⼤太阳，你需要准备⾬伞和帽⼦.如果下⾬，我有⾬伞可⽤，如果出⼤太阳，可以⽤帽⼦，也有可能天⽓刚刚好，⾬伞和帽⼦都⽤不着，这叫⽩带。
1.6 回顾⼏个常见异常2 try-catch⾃⼰处理异常的两种⽅试try…catch…finallythrows2.1 try-catch异常处理⽅式2.2 try-catch-catch 多个catch处理⽅式2.3 try-catch-catch 多个异常-另⼀种写法2.4 多个异常处理的⼀个注意事项catch中⽗类的Exception只能放在最后⾯catch⼀个原则，先由⼦类处理异常，⼦类不能处理异常，再由⽗类处理try {//1.有可能出现数组越界异常int[] arr = {1,2,3};System.out.println(arr[1]);//2.算术异常int a = 10 / 2;//3.空指针异常int[] arr1 = null;//NullPointerException np;System.out.println(arr1[0]);}catch (ArrayIndexOutOfBoundsException e) {System.out.println("数组越界异常");} catch (ArithmeticException e) {System.out.println("算术异常");} catch (Exception e) {System.out.println("其它异常");}2.5 "编译时异常"和"运⾏时异常Java中的异常被分为两⼤类："编译时异常"和"运⾏时异常"。
java exception 继承
java exception 继承Java Exception 继承Java 异常机制中提供了继承机制，抽象的异常类可以被其子类继承，子类可以添加新的信息和功能，以获得更详细的异常信息和更多的处理能力。
Java 中的异常类都以 Throwable 类作为基类，而 Throwable 类又以 Error 和 Exception 为子类。
Error 表示 Java 运行时系统无法处理的严重错误，而 Exception 则表示 Java 程序可以处理的异常。
Java Exception 提供了两种类型的继承机制：checked exception 和 unchecked exception，checked exception 指的是继承于 Exception 类，需要捕获处理，而 unchecked exception 指的是继承于 RuntimeException，使用 try 块捕获处理是可选的。
Java Exception 继承关系如下：Throwable- Error- OutOfMemoryError- StackOverflowError- NoClassDefFoundError- ...- Exception- IOException- InterruptedException- SecurityException- SQLException- ...- RuntimeException- ArithmeticException- IllegalArgumentException- NullPointerException- NumberFormatException- ...从上面可以看到，Error 类下面有若干个子类，Exception 类下面有若干个子类，而 RuntimeException 类下面又有若干个子类。
可以看出，在 Java 中，可以通过继承创建新的异常类型，以便更好地捕获和处理异常。
Java异常基础Exception
Java异常基础ExceptionJava中的异常 Exception ng.Exception类是Java中所有异常的直接或间接⽗类。
即Exception类是所有异常的根类。
⽐如程序： public class ExceptionTest{public static void main(String[] args){int a = 3;int b = 0;int c = a / b;System.out.println(c);}} 编译通过，执⾏时结果： Exception in thread "main" ng.ArithmeticException: / by zero at com.learnjava.exception.ExceptionTest.main(ExceptionTest.java:9) 因为除数为0，所以引发了算数异常。
⽐较常见的异常还有这种：空指针异常 ng.NullPointerException是空指针异常，出现该异常的原因在于某个引⽤为null，但却调⽤了它的某个⽅法，这时就会出现该异常。
Java中的异常分为两⼤类： 1.Checked Exception（⾮Runtime Exception） 2.Unchecked Exception（Runtime Exception）运⾏时异常 RuntimeException类是Exception类的⼦类，它叫做运⾏时异常，Java中的所有运⾏时异常都会直接或者间接地继承⾃RuntimeException类。
Java中凡是继承⾃Exception，⽽不继承⾃RuntimeException类的异常都是⾮运⾏时异常。
异常处理的⼀般结构try{// 可能发⽣异常的代码 // 如果发⽣了异常，那么异常之后的代码都不会被执⾏}catch (Exception e){// 异常处理代码}finally{// 不管有没有发⽣异常，finally语句块都会被执⾏} ⽐如本⽂最开始的除法运算代码，加⼊异常处理之后： public class ExceptionTest{public static void main(String[] args){int c = 0;try{int a = 3;int b = 0;// 这块代码出现了异常c = a / b;// 那么异常之后的代码都不会被执⾏System.out.println("Hello World");}catch (ArithmeticException e){e.printStackTrace();}finally{//不管有没有发⽣异常，finally语句块都会被执⾏System.out.println("Welcome");}System.out.println(c);// 当b为0时，有异常，输出为c的初始值0}}多个catch ⼀个try后⾯可以跟多个catch，但不管多少个，最多只会有⼀个catch块被执⾏。
java异常处理Exception及子类父类异常处理
java异常处理Exception及⼦类⽗类异常处理
我看别⼈的⾯经中有⼀道题⽬就问到了Exception，即java的异常处理的，我以前也学了java的异常处理，但是我查了下，看了别⼈的博客关于写的exception异常处理，我发现，⾃⼰学的不牢固，只学到了⼀点⽪⽑⽽已，在看了那么多博客和资料后，我做下总结吧，不然我⼤脑都混乱了。
java的中异常祖先是Throwable，Throwable的直接⼦类是Exception和Error。
Error通过单词我们就知道，是错误的意思，这种错误⼀般是jvm运⾏产⽣的错误，出现这种错误，我们的程序不能解决，⽐如内存溢出oom，堆溢出等。
这种错误，我们不必处理，直接让jvm抛出报错，我们没办法解决就不管了。
Exception中⽂意思是异常，那么Exception⼜分为检查性异常和⾮检查性异常。
⽐如RuntimeException类及⼦类就是⾮检查性异处，表⽰运⾏时出现的异常，有数组越界，空指针异常，我们也可以不进⾏处理，让jvm⾃⼰抛出异常，当然如果我们可以预见这种异常的话，最好在程序中进⾏判断检查，程序写健壮些，有的这种异常就可以避免了。
effect java有这种处理的推荐，具体的可以看看这本书。
Exception还有⼀类是检查性异常，这是除RuntimeException类及⼦类外的Exception类和Exception类的其他⼦类。
检查性异常，必须要进⾏异常处理的或者抛出，否则编译器会报错。
下⾯这是我⾃⼰总结和测试出来，很⽅便解决出现的各种异常，代码如下：
⽗类异常：
⼦类异常：。
exception的方法
exception的方法Exception的方法Exception是Java中一个非常重要的类，它是所有异常类的父类。
在Java中，异常是一种程序运行过程中的错误或异常情况，而Exception类提供了一系列的方法来处理这些异常。
本文将介绍Exception类中常用的方法。
1. getMessage()getMessage()方法返回异常的详细描述信息。
通常情况下，该方法会返回异常类中定义的错误信息，用于帮助开发者迅速定位错误的原因。
2. printStackTrace()printStackTrace()方法将异常的跟踪栈信息打印到标准错误流。
这些跟踪信息包括异常的类型、异常出现的位置以及调用栈信息，对于定位和调试异常非常有帮助。
3. toString()toString()方法返回异常对象的字符串表示形式。
通常情况下，该方法会返回异常类的名称和详细描述信息。
4. getCause()getCause()方法返回导致当前异常的原因。
如果当前异常是由其他异常引发的，那么getCause()方法将返回原因异常。
5. getLocalizedMessage()getLocalizedMessage()方法返回异常的本地化描述信息。
该方法可以根据不同的语言环境返回不同的描述信息，方便国际化处理。
6. fillInStackTrace()fillInStackTrace()方法重新填充异常的跟踪栈信息。
通常情况下，该方法会在异常被抛出时自动调用，重新生成跟踪栈信息。
7. equals()equals()方法判断两个异常对象是否相等。
通常情况下，异常对象的相等性是根据异常类的类型和详细描述信息来确定的。
8. hashCode()hashCode()方法返回异常对象的哈希码。
通常情况下，哈希码是根据异常类的类型和详细描述信息计算得出的。
9. getStackTrace()getStackTrace()方法返回异常对象的跟踪栈信息。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
TestCorporation.java
8 Process and Portfolio Management © 2005 IBM Corporation
Java的基本类库中常用的异常 Java的基本类库中常用的异常
NullPointerExcepiton: 应用程序试图在需要对象的地 方使用 null 时，抛出该异常 IllegalArgumentException: 抛出的异常表明向方法传 递了一个不合法或不正确的参数 IndexOutOfBoundsException: 指示某排序索引(例如 指示某排序索引 例如 对数组，字符串或向量的排序)超出范围时抛出 对数组，字符串或向量的排序 超出范围时抛出 ClassCastException: 类型转换异常 SQLException: 数据库访问异常
7
Process and Portfolio Management
© 2005 IBM Corporation
异常匹配
抛出异常的时候， 抛出异常的时候，异常处理系统会按照你书写代码的顺 序找出“最近”的处理程序。找到匹配的处理程序之后， 序找出“最近”的处理程序。找到匹配的处理程序之后， 它就认为异常将得到处理， 它就认为异常将得到处理，然后就不再继续查找 一般地，将捕获父类异常的代码块放在捕获子类异常的 一般地， 代码块的后面，捕获ng.Exception的代码块放在 代码块的后面，捕获 的代码块放在 最后面
14
Process and Portfolio Management
© 2005 IBM Corporation
Thank You！ You！
Q&A Time
15
Process and Portfolio Management
© 2005 IBM Corporation
9
Process and Portfolio Management
© 2005 IBM Corporation
自定义异常与异常信息获取
自定义异常只需要继承Exception或RuntimeException 或 自定义异常只需要继承 父类即可 在自定义异常中调用super（info）初始化异常消息 （ 在自定义异常中调用 ） 在捕获异常时，获取异常的信息可以通过： 在捕获异常时，获取异常的信息可以通过： System.out.println(e.getMessage())；获取自定义异 ； 常时构造器 常时构造器中传入的异常消息 System.out.println(e);获取异常名与异常消息 获取异常名与异常消息 e.printStackTrace();获取异常名、异常消息和异常抛 获取异常名、 获取异常名 出的堆栈信息（一般用于程序调试） 出的堆栈信息（一般用于程序调试）
}[可有 多个 可有0~多个 语句] 可有 多个catch语句 语句 finally {
不管异常是否发生都要执行的代码块
}[可省略 可省略] 可省略
TestMultiException.java，TestOnOff.java ExceptionDemo.java，HandleException.java ， ，
Java SE
Copyright© 2008 - 2009 WitBridge
第六讲
Exception
2
Process and Portfolio Management
© 2005 IBM Corporation
异常
异常（ 对此感到意外”的意思。 异常（Exception）有“对此感到意外”的意思。异常 ） 发生时若不加以处理， 发生时若不加以处理，整个程序将终止 异常是一种处理错误的方式。与传统方法相比， 异常是一种处理错误的方式。与传统方法相比，它有很 多优点。它可以避免返回代号、检查错误导致的“ 多优点。它可以避免返回代号、检查错误导致的“意大 利面条式逻辑” 利面条式逻辑”，还可以将检查错误的代码同知道如何 处理错误的代码区分开
TestIOException.java
5 Process and Portfolio Management © 2005 IBM Corporation
Java异常处理机制 Java异常处理机制
try {
需要保护的代码块
} catch (异常类型 实例 { 异常类型 实例)
捕捉到异常时的处理代码块
6 Process and Portfolio Management © 2005 IBM Corporation
异常代码执行分析
如果用try关键字保护的代码块没有出现意外， 如果用 关键字保护的代码块没有出现意外，那么程序 关键字保护的代码块没有出现意外 流程不会进入用catch关键字进行处理的代码块 流程不会进入用 关键字进行处理的代码块 如果用try关键字保护的代码块出现意外， 如果用 关键字保护的代码块出现意外，那么程序流程 关键字保护的代码块出现意外 就直接跳转到用catch关键字进行处理的代码块 一个 关键字进行处理的代码块,一个 就直接跳转到用 关键字进行处理的代码块 一个try 可以对应多个catch语句 可以对应多个 语句 如果有finally代码块，那么该代码块无论意外是否发生 代码块， 如果有 代码块 都会执行
4 Process and Portfolio Management © 2005 IBM Corporation
Checked/Unchecked Exception
Java提供了两类主要的异常：Unchecked Exception和 提供了两类主要的异常： 提供了两类主要的异常 和 Checked Exception。所有的 。所有的Checked Exception是从 是从 ng.Exception类衍生出来的，而Unchecked 类衍生出来的， 类衍生出来的 Exception则是从 则是从ng.RuntimeException或 则是从 或 ng.Error类衍生出来的 类衍生出来的 一般而言，Checked Exception这类异常必须放在 一般而言， 这类异常必须放在 try/catch语句块中处理，处理后程序可以继续执行， 语句块中处理， 语句块中处理 处理后程序可以继续执行， Unchecked Exception通常会暗示着程序上的错误 通常会暗示着程序上的错误 ），这类异常可以不放在 （Error/RuntimeException），这类异常可以不放在 ）， try/catch语句块中处理，若发生该错误一般会造成程序 语句块中处理， 语句块中处理 无法继续执行下去
TestException.java，TestException1.java ，
3 Process and Portfolio Management © 2005 IBM Corporation
异常体系结构 异常体系结构
ng.Throwable（任何可以作为异常被抛出的类型） （任何可以作为异常被抛出的类型） ng.Error（用于Java 虚拟机报告系统错误） （用于 虚拟机报告系统错误） ng.Exception （可以被抛出并处理的基本异常类型） 可以被抛出并处理的基本异常类型） ng.RuntimeException（运行期异常） （运行期异常）
AccountDemo. java
11 Process and Portfolio Management © 2005 IBM Corpora时需要抛出另一个新的异常， 如果要在捕获到异常时需要抛出另一个新的异常，将原始 异常（引发新异常的根异常）带上， 异常（引发新异常的根异常）带上，这样可以形成一个异 常链 通过e.getCause() 可以获取引发该异常的异常 通过
BalanceNotEnoughException. java
10 Process and Portfolio Management © 2005 IBM Corporation
自定义方法中声明和抛出异常
throws关键词，声明方法有可能会抛出的异常（也可能 关键词，声明方法有可能会抛出的异常（ 关键词 不抛出，只是声明有这种可能） 不抛出，只是声明有这种可能） throw关键词，实现抛出异常的动作 关键词， 关键词
TestExceptionChain.java
12 Process and Portfolio Management © 2005 IBM Corporation
异常的限制
当方法重写的时候， 当方法重写的时候，你只能抛出在父类方法的异常声明里 列出的那些异常。 列出的那些异常。 这个限制很有用，因为这样的话， 这个限制很有用，因为这样的话，对父类能工作的代码应 用到子类对象的时候，一样能够工作，异常也不例外。 用到子类对象的时候，一样能够工作，异常也不例外。
TestAnimal.java
13 Process and Portfolio Management © 2005 IBM Corporation
编写异常处理代码的建议
能用检验避免异常的地方尽量先检验 能够抛出异常的尽量抛出异常,而不要返回 能够抛出异常的尽量抛出异常 而不要返回null或者其他 而不要返回 或者其他 无法处理的值给上一级 产生异常后尽量抛出给上一级上下文,由上一级上下文决 产生异常后尽量抛出给上一级上下文 由上一级上下文决 定处理方式,而不要自行捕捉和处理 定处理方式 而不要自行捕捉和处理