Java试听课-6异常
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 之间的数字。
异常
1 什么是异常
程序的编译和运行结果如下: Java Visaul Basic C++ Exception in thread "main" ng.ArrayIndexOutOfBoundsException: 3 at Exception2.main(Exception2.java:8) 上面的例子编译可以通过,但运行时出现异常信息被抛出。 在其循环被执行四次之后,数组下标溢出,程序终止,并带 有错误信息,就象前面所示的程序那样。
1 什么是异常
【例3】被0除的例子 // Exception3.java class Exception3{ public static void main(String args[]){ int a=0; System.out.println(5/a); } } 我们编译这个程序得到其字节码文件,然后运行它,屏幕上的显示如下: Exception in thread "main" ng.ArithmeticException: / by zero at Exception3.main(Exception3.java:5) 因为除数不能为0,所以在程序运行的时候出现了除以0 因为除数不能为0,所以在程序运行的时候出现了除以0溢出的异常事件。
1 什么是异常
当编译这个程序时,屏幕上会输出下面的信息: Exception1.java:5: unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown FileInputStream fis = new FileInputStream("text.txt"); ^ Exception1.java:7: unreported exception java.io.IOException; must be caught or declared to be thrown while((b=fis.read())!=while((b=fis.read())!=-1) { ^ Exception1.java:10: unreported exception java.io.IOException; must be caught ordeclared to be thrown fis.close(); ^ 3 errors
Java异常类型及处理
Java异常类型及处理⽬录⼀、异常定义⼆、异常的结构和分类三、异常的处理和捕获四、⾃定义异常五、异常的应⽤1.打印堆栈2.弹出流程六、注意点总结⼀、异常定义异常就是“意外、例外”的意思,也就是⾮正常情况。
异常本质上是程序上的错误,包括程序逻辑错误和系统错误。
异常的处理基本上就是⽤来兜底的,也是程序开发中程序不愿意看到的。
异常最基本的信息就是线程的堆栈信息。
⼆、异常的结构和分类Throwable主要分为Error和Exception。
错误:Error类以及他的⼦类的实例,代表了JVM本⾝的错误。
错误不能被程序员通过代码处理,躺平解决就好,不要反抗。
常见的错误有下⾯这些异常:Exception以及他的⼦类,代表程序运⾏时发送的各种不期望发⽣的事件。
可以被Java异常处理机制使⽤,是异常处理的核⼼,能在程序中解决的都不叫事。
常见的异常有这么多。
三、异常的处理和捕获异常想要处理肯定要先捕获到异常才可以,怎么捕获异常呐,Java给我提供了⼏个关键字,每个关键字怎么⽤呐?1、try,catch 就是直接捕获异常,catch 内的异常类型是能捕获的类型,⼀般如果有多个异常,从上到下的顺序是异常范围越来越⼤。
注:ErrorCodeException的定义可以参考⾃定义异常。
public static void second(String[] args) {try {throw new ErrorCodeException("1123");} catch (ErrorCodeException e) {e.printStackTrace();}catch (Exception e){e.printStackTrace();}}2、try catch finally 增加了finally关键字,就是在异常之后还能做⼀些事情,⽐如常见的关闭输⼊流,输出流,是程序最后的倔强。
public static String readFileContent(String fileName) {File file = new File(fileName);BufferedReader reader = null;StringBuffer sbf = new StringBuffer();try {reader = new BufferedReader(new FileReader(file));String tempStr;while ((tempStr = reader.readLine()) != null) {sbf.append(tempStr);}reader.close();return sbf.toString();} catch (IOException e) {e.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e1) {e1.printStackTrace();}}}return sbf.toString();}3、throw 主要⽤来创建⼀个异常,因为程序中可能需要抛出⼀个异常,⽐如我们游戏服务器游戏逻辑验证客户端参数不通过,会主动抛出⼀个⾃定义的异常4、throws 主要⽤在⽅法签名上,当我们读写⽂件或者反射的时候,如果不⽤try catch 就会发现⽅法签名后有⼀堆的异常需要处理。
Java异常处理
该程序段将输出: Array Index out of Bounds
22
不正确用法:
将两个catch块的顺序对调: int a[] = new int[10]; try{
for(int i=0;i<=10;i++) a[i]=i;
}catch(Exception e){ System.out.println("There is an exception");
18
结果分析:
例题的除数为0时返回为0的问题,通过 语句if (d!=0 || n[i]==0)得以改进;
该程序分别在不同的层次对两种异常进 行了处理;
异常处理后的程序保持了良好的健壮性, 体现了“带病工作”的能力;
19
异常处理
异常处理器(exception handler)
try t{ry语句块定义了异常处理器的范围 .c.at.ch语句块捕捉try语句块抛出的异常 t}ryc{atch (ArrayIndexOutOfBoundsException e) { // Code that might generate exceptions } caStcyhs(tTeymp.eo1uitd.1p)ri{ntln(e); }//cHaatcnhdl(eIeOxEcxecpetipotnios nofeT)y{pe1 } caStcyhs(tTeymp.eo2uitd.2p)ri{ntln(e); }// Handle exceptions of Type2 } catch(Type3 id3) { // Handle exceptions of Type3 } // etc ...
20
异常处理
catch 语句的顺序
6 异常
异常:是什么?是对问题的描述。
将问题进行对象的封装。
------------异常体系:Throwable|--Error|--Exception|--RuntimeException异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
--------------throw和throws的用法:throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。
必须要在函数上声明,否则编译失败。
注意,RuntimeException除外。
也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
如果函数声明了异常,调用者需要进行处理。
处理方法可以throws 可以try。
--------------异常有两种:编译时被检测异常⏹该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
该异常被标识,代表这可以被处理。
运行时异常(编译时不检测)⏹在编译时,不需要处理,编译器不检查。
⏹该异常的发生,建议不处理,让程序停止。
需要对代码进行修正。
--------------异常处理语句:try{需要被检测的代码;}catch (){处理异常的代码;}finally{一定会执行的代码;}有三个结合格式:1. try{}catch (){}2. try{}finally{//关资源}3. try{}catch (){}finally{}注意:1,finally中定义的通常是关闭资源代码。
因为资源必须释放。
2,finally只有一种情况不会执行。
当执行到catch(Exception e){System.exit(0)};fianlly不会执行。
--------------自定义异常:定义类继承Exception或者RuntimeException1,为了让该自定义类具备可抛性。
第6章-异常与异常处理
第6章异常和异常处理Java语言作为面向对象的程序设计语言,和其他早期程序设计语言一样,在编写过程中会出现除语法之外的其他错误。
在Java中引进了异常和异常类来进行错误处理。
本章将介绍异常的概念及其异常处理的方法。
6.1 异常处理示例异常处理是程序设计中一个非常重要的方面,也是程序设计的一大难点,从C开始,你也许已经知道如何用if...else...来控制异常了,也许是自发的,然而这种控制异常痛苦,同一个异常或者错误如果多个地方出现,那么你每个地方都要做相同处理,感觉相当的麻烦!下面通过一个简单的例子,初步了解就ava中的异常。
【例6-1】运行下列程序,从输出结果中分析出现何种异常。
1 class Excep{2 public int division(int a,int b)3 {4 return a/b;5 }6 }7 class Example6_1{8 public static void main(String[] args){9 Excep excep=new Excep();10 excep.division(5,0);11 }12 }程序运行结果:D:\java\6>javac Example6_1.javaD:\java\6>java Example6_1Exception in thread "main" ng.ArithmeticException: / by zeroat Excep.division(ExcepTest.java:3)at ExcepTest.main(ExcepTest.java:8)程序分析:从程序的输出结果中表明:在main函数中出现了异常错误,但无法预知在哪里出现了异常。
6.2 异常概述任何一个软件程序在运行初期都会产生错误,Java程序也不例外。
例如,内存空间不足,程序控制试图打开一个不存在的文件,网络连接数据中断,数组下标越界等等。
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继承的那些⾮受查异常。
警告:如果在⼦类中覆盖了超类的⼀个⽅法,⼦类⽅法中声明的受查异常不能⽐超类⽅法中声明的异常更通⽤(也就是说,⼦类⽅法中可以抛出更特定的异常,或者根本不抛出任何异常)。
Java中的异常处理机制
Java中的异常处理机制Java是一种面向对象的编程语言,异常处理是Java编程中非常重要的一个方面。
在Java程序中,异常是指程序执行时的错误或异常状况。
如果不处理异常,则程序将终止执行并抛出一个异常。
Java语言提供了一种异常处理机制,使程序员能够有效地处理异常情况,提高程序的健壮性和可靠性。
异常处理机制可以帮助我们更好地管理程序的运行过程,提高代码的可读性和重用性。
Java异常处理机制的本质是一个异常对象的抛掷和接收机制,它由以下三个部分组成:异常的产生、异常的抛掷和异常的接收与处理。
一、异常的产生异常通常由以下几种情况产生:1. 编程人员故意或错误地抛出一个异常,如:throw new Exception("自定义异常")。
2. 运行时出现错误,如:数组越界、空指针等。
3. 系统出现异常,如:文件无法打开、网络连接中断等。
二、异常的抛掷当程序中出现异常时,有两种方式来抛出异常:1. 使用throw语句抛出异常,如:throw new Exception("自定义异常")。
2. 让系统自动抛出异常,如:空指针引用异常、除零异常等。
抛出异常后,程序会停止执行,并将异常对象抛出到调用该方法的地方。
如果该方法没有捕获异常,则该方法终止执行并将异常传递给调用该方法的下一个方法,直到异常被捕获或到达程序的顶层。
三、异常的接收与处理接收并处理异常是Java中异常处理机制的最后一步。
如果异常被捕获,程序将通过捕获异常的处理程序继续执行,而不会终止程序的执行。
Java中提供了try-catch语句块来捕获异常。
try-catch语句块的语法结构如下:try{代码块 //有可能抛出异常的代码}catch(异常类型1 异常变量名){代码块 //异常类型1的处理逻辑}catch(异常类型2 异常变量名){代码块 //异常类型2的处理逻辑}当try语句块中的代码抛出一个异常时,会跳转到匹配该异常类型的catch语句块。
6第六章 异常
《JAVA程序设计》课程
6.2 异常处理
调用者通过try-catch-finally捕获并处理异常;通过throws继续声明异常,如果调用者不知道如何处理异常,可以继 续通过throws声明异常,让上一级处理异常。main方法声明的异常将由JAVA虚拟机来处理。 在案例6-3中,将计算商的任务封装到divide()方法中,在main()方法中调用该方法,并对可能产生的异常进行处理, 请查看案例6-4。 教材word版\第六章\新建 Microsoft Word 文档.docx 在案例6-4中,在main方法中不用try-catch,而是继续声明异常,此时由JAVA虚拟机来处理,请查阅案例6-5. 教材word版\第六章\新建 Microsoft Word 文档.docx (4)throw(抛出异常) 在JAVA的异常处理机制中,程序应能够捕获异常并进行异常处理,但前提条件是在方法执行中能够将产生的异常抛出。 JAVA语言中异常的对象有两个来源:一是JAVA运行时环境自动抛出系统产生的异常,这些异常总是要抛出即自动抛出, 如除数为0的异常;二是系统无法自动发现并解决,即程序员自己抛出的异常,这个异常可以是程序员自己定义的,也 可以是JAVA语言中定义的,如年龄不在正常范围内,性别输入不是“男”或“女”等,此时可以用throw关键字抛出异 常,把问题提交给调用者解决。格式如下:
《JAVA程序设计》课程
6.2 异常处理
throw new Exception() 示例请查阅案例6-6。 教材word版\第六章\新建 Microsoft Word 文档.docx 请调试程序观察运行结果。
对比throw和throws区别: 作用不同:throw用于程序员自动产生并抛出异常,throws用于声明在该方法内抛出异常; 位置不同:throw位于方法体内部,可以作为单独语句使用,throws必须在方法参数列表的后面不能 单独使用; 内容不同:throw抛出一个异常对象,而且只能是一个。Throws后面跟异常类,而且可以跟多个异常 类。 6.2.3 项目实施 请参考项目6-3所示。
JAVA讲义第6章
第6章Java异常处理6.1概述异常就是在程序运行时由代码所产生的不正常状态。
换句话说,异常就是一个运行错误。
在不支持异常处理的计算机语言中,错误必须被人工进行检查和处理,这显然麻烦而低效。
Java语言提供了异常处理机制,为方法的异常终止和出错处理提供了清楚的接口。
异常(exception)也是异常事件(exceptional event)的简称,它是在程序运行中出现的违背指定正常流向的事件。
许多不同种类的错误可以导致异常,从严重的硬件错误到简单的编程错误。
当在Java方法中发生这样的错误时,方法将创建一个异常对象,并把它交给运行系统处理,运行系统负责找到处理错误的代码并执行之。
异常对象包括关于异常的信息、类型和错误发生时程序的状态以及对该错误的详细描述。
在Java中,创建一个异常对象并把它送到运行系统叫做抛出异常。
在抛出异常后,运行系统将寻找合适的方法来处理异常。
如果产生的异常类与所处理的异常类一致,则认为找到了合适的异常处理方法。
如果运行系统找遍了所有方法而没有找到合理的异常处理方法,则运行系统将终止Java程序的运行。
异常处理也叫做捕捉异常。
Java中的每个异常都是一个对象,它是ng包中Throwable类或其子类的实例对象。
Throwable类有两个子类:Exception类和Error类。
Exception类是可以被捕捉并且可能恢复的异常类,也可以继承Exception类生成自己的异常类。
Error类一般被认为是不可恢复和不可捕捉的异常类。
6.2 异常的类型6.2.1异常类的层次结构图6.1异常类的层次java 语言用继承的方式来组织各种异常。
所有的异常都是Throwable 类或子类,而Throwable 类又直接继承于object 类。
Throwable 类有两个子类:Error 类与Exception 类。
Exception 类又进一步细分为RuntimeException (运行异常)类和Non-RuntimeException (非运行异常)类。
java 异常处理机制
java 异常处理机制Java 异常处理机制Java 是一门强类型、面向对象、解释性语言,它的异常处理机制使得程序的可靠性大大提升。
当 Java 程序运行时,一旦出现异常,就必须通过异常处理机制来防止程序崩溃,并进行错误的处理。
本文将重点介绍 Java 的异常处理机制。
一、什么是异常处理?异常(exception)是程序运行时出现的非正常情况,如一个数除以零、文件不存在等。
发生异常后,程序通常不再继续进行下去,而是采取相应的措施,比如输出错误信息、关闭文件、弹出对话框等。
异常处理(exception handling)是程序针对异常的一种机制,它可以捕捉异常并进行相应的处理,从而保证程序的正常运行。
Java 异常分类Java 异常可以分为三类:运行时异常、受检异常和错误。
1. 运行时异常(RuntimeException)运行时异常也称为非检查异常,这类异常在程序运行时可能发生,但编译器在编译时并不会检查其是否处理。
主要包括:- 空指针异常(NullPointerException)- 数组下标越界异常(ArrayIndexOutOfBoundsException)- 数字格式异常(NumberFormatException)- 类型转换异常(ClassCastException)- ……2. 受检异常(CheckedException)受检异常需要在代码中显式地处理或声明抛出。
这类异常通常不是由程序错误引起的,而是由外部因素导致,如文件不存在、网络连接断开等。
主要包括:- 文件不存在异常(FileNotFoundException)- IO 异常(IOException)- SQL 异常(SQLException)- ……3. 错误(Error)错误通常指与虚拟机相关的问题,如栈溢出、内存不足等。
错误不需要程序显式地处理,通常也很难处理。
主要包括:- OutOfMemoryError- StackOverflowError- NoClassDefFoundError- ……Java 异常处理机制Java 异常处理机制的核心思想是“捕捉和处理异常”,这通过以下关键字和语句来实现:1. try-catch 语句try-catch 语句用于捕获异常并进行处理。
java异常处理机制的原理和应用
Java异常处理机制的原理和应用1. 异常处理机制的概述Java异常处理机制是一种用于处理程序在运行时可能出现的异常情况的机制。
在Java程序中,当某个方法出现了异常,可以选择将异常抛出并交给上层调用者处理,也可以捕捉异常并在当前方法中进行处理。
异常处理机制能够有效地保护程序免受意外错误的影响,并提供了一种标准的处理方式,使程序更加健壮和可读。
2. 异常的分类Java中的异常分为两大类型:可查异常和运行时异常。
2.1 可查异常可查异常是指在Java代码中,编译器能够预见到可能会出现的异常情况。
这些异常一般都是由外部因素引起的,例如输入/输出操作中的文件不存在、网络连接中断等。
在编写程序时,必须对可能发生的可查异常进行处理,否则编译器会报错。
可查异常包括: - IOException:输入/输出操作异常 - SQLException:SQL数据库操作异常- FileNotFoundException:文件不存在异常- MalformedURLException:URL格式异常等2.2 运行时异常运行时异常是指由于程序逻辑错误或代码疏忽等原因导致的异常。
与可查异常不同,运行时异常一般不需要进行显式的处理,编译器也不会强制要求捕获这些异常。
常见的运行时异常包括: - NullPointerException:空指针异常 - ArrayIndexOutOfBoundsException:数组索引越界异常 - ArithmeticException:算术运算异常 - IllegalArgumentException:非法参数异常等3. 异常处理机制的原理Java的异常处理机制采用异常处理框架来实现,主要包括以下几个关键组成部分:3.1 try-catch块Java中的异常处理机制通过使用try-catch块来捕获和处理异常。
在try块中,我们编写可能会引发异常的代码。
当在try块中的代码出现异常时,会立即跳转到与之相匹配的catch块进行异常处理,从而避免程序的崩溃。
Java中的异常处理技术
Java中的异常处理技术Java是一种高级编程语言,它非常流行且广泛应用于现代软件开发领域。
在Java程序中,可能会出现各种错误或异常情况,这就需要开发人员使用异常处理技术来保证程序的稳定性和可靠性。
一、什么是Java异常?在Java程序中,异常是一种特殊的事件,它表示程序在执行过程中遇到了意外情况,例如:输入输出错误、空指针引用、数组越界访问、除数为零等。
当这些异常事件发生时,程序会抛出异常对象并中断当前的执行流程。
二、Java异常分类在Java中,异常分为两种:受检异常checked exception和非受检异常unchecked exception。
1. 受检异常checked exception受检异常是指那些Java编译器在编译时会强制要求程序员显式地对其进行处理的异常。
例如:文件不存在、网络连接中断、输入输出错误等。
针对受检异常,程序员必须在代码中显式地处理或者使用throws关键字声明抛出异常。
2. 非受检异常unchecked exception非受检异常是指Java运行时系统会自动抛出的异常,如:空指针、数组越界、除数为零等运行时异常。
这些异常不需要在代码中显式声明或捕获,可以根据需要进行处理。
三、Java异常处理方法Java异常处理技术有三种基本方法:try-catch-finally、throws 和断言。
1. try-catch-finally语句try-catch-finally语句是Java中最常用的异常处理工具,它的作用是捕获并处理异常。
try语句块中通常是会出现异常的代码段,catch语句块中是对异常进行处理的代码,finally语句块则表示无论是否抛出异常都会执行的代码。
例如,下面的代码演示了如何使用try-catch-finally语句处理受检异常:try{FileReader reader = new FileReader("file.txt");BufferedReader br = new BufferedReader(reader);String line;while ((line = br.readLine()) != null) {System.out.println(line);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {try {br.close();reader.close();} catch (IOException e) {e.printStackTrace();}}2. throws异常声明throws异常声明是一种将异常传递到调用方法的方式。
Java:详解Java中的异常
Java:详解Java中的异常⽬录Java异常常见异常throw和throws的区别final、finally、finalize的区别总结Java异常Java中的异常:⼜称例外,是⼀个在程序执⾏期间发⽣的事件,它中断正在执⾏程序的正常指令流异常的分类:Throwable:类是java语⾔中所有错误或异常的超类,这意味着只要指⽰错误或异常,那么肯定是thrawble⼦类的实例,但是事实上由于错误异常内容过于庞⼤,所以设计⼈员将它们分开来,这就是thrawble的两个⼦类,Error和ExceptionError类是负责错误,它指程序运⾏的时候遇到硬件或操作系统的错误,这些错误都是严重并且致命的,是依靠程序⾃⾝⽆法解决的。
Exception是运⾏时的错误,它可以被捕获并处理(运⾏时异常:RuntimeException类及其⼦类异常,这些异常都是不检查异常,程序中可以选择捕获处理,也可以不处理,这些异常⼀般由程序逻辑错误引起,程序应该从逻辑⾓度尽可能避免这类异常的发⽣。
⾮运⾏时异常:RuntimeException以外的异常,类型上都属于Exception类及其⼦类,从语法⾓度上讲是必须处理的异常,如果不处理,程序就不能通过编译)常见异常异常的处理:通过5个关键字控制 try catch throw throws finally捕获异常 try⾥⾯的代码越少越好 catch中必须含有内容,哪怕是简单的提⽰try{可能出现异常的代码}catch(异常的类名变量名){针对异常的处理⽅式}finally{释放资源}try{可能出现异常的代码}catch(异常的类名变量名){针对异常的处理⽅式}try{可能出现异常的代码}catch(异常的类名1 变量名){针对异常的处理⽅式}catch(异常的类名2 变量名){针对异常的处理⽅式}...编译期异常和运⾏期异常运⾏期异常:代码不够严谨,需要修改代码编译期异常:必须处理,否则编译不通过ThrowableString getMessage() 详细信息字符串String toString() 返回异常的简短描述throws 抛出异常必须写在⽅法声明的后⾯尽量不要在主⽅法上抛出异常throws 异常类名throw 在⽅法内部主动抛出的异常throw 异常的对象finally 保证资源⼀定得到释放try{可能出现异常的代码}catch(异常的类名变量名){针对异常的处理⽅式}finally{释放资源}⾃定义异常继承Exception(编译期异常)继承RunTimeException(运⾏期异常)throw和throws的区别1.前者写在⽅法内部后者写在⽅法声明的后⾯2.前者后⾯跟的是异常对象后者跟的是异常类名3.前者后⾯只能是⼀个异常对象后者可以跟多个⼀场类名final、finally、finalize的区别final修饰类类不能被继承修饰⽅法⽅法不能被覆盖修饰变量变量为常量只能赋值⼀次finally:异常处理中的组成部分,作⽤是释放资源,放在finally中的代码⼀定会执⾏finalize:是Object类中的⽅法,⽤于垃圾回收总结本篇⽂章就到这⾥了,希望能给你带来帮助,也希望您能够多多关注的更多内容!。
企业Java培训课件之异常处理
演示示例:程序中的异常
正常情况: 输入:200 40
异常情况: 输入:B 输入:200 0
目录
异常的概念 异常处理
声明/抛出异常 自定义异常
总结
二、五个关键字 2-1
Java的异常处理是通过5个关键字来实现的:try、 catch、 finally、throw、throws
捕获异常
try catch
public static void divide() throws Exception { //……
}
public static void main(String[] args) { try { divide(); } catch (Exception e) {//……}}
divide()方法没有处理异 常,而是声明异常
this.sex = sex;
抛出异常
else { throw new Exception("性别必须是“男”或者“女”!");
方式1:调用者通过trycatch捕获并处理异 常
// public static void main(String[] args) throws Exception {
// divide(); // }
方式2:调用者通过 throws继续声明异常
演示示例:使用throws声明异常
三、throw抛出异常 3-2
}
try catch try-catch 块后的代码段
二、异常处理 2-3
第二种情况
异常是一种特殊的对象,类型为 ng.Exception或其子类
public void method(){
try { // 代码段 1 // 产生异常的代码段 2 // 代码段 3
java-6 异常处理
第6章 异 常 处 理
6.3.2 程序的测试及 程序的测试及JUnit
在实际开发过程中,程序的修改是经常要进行的过程,例 如实现某个功能原先有一个算法,后来又找到一个新的算 法,在新的算法实现时,必须保证程序在修改后其结果仍 然是正确的.在现代的开发过程中,一种重要的措施是使 用测试.也就是说,在编写程序代码的同时,还编写测试 代码来判断这些程序是否正确.有人更进一步地把这个过 程称为"测试驱动"的开发过程.编写测试代码,表面上 增加了代码量,但实际上,由于它保证了它在单元级别的 正确性,从而保证了代码的质量,减少了后期的查错与调 试的时间,所以实际上它提高了程序的开发效率.
throw new Exception("some message");
(3)重新生成并抛出一个新异常,该异常中包含了当前 异常的信息,如:
throw new Exception("some message",e);
例:ExceptionCause.java
第6章 异 常 处 理
6.3 断言及程序的测试
从以上语句可以看来,在一定意义上JUnit是对 assert语句的极大的扩充,并提供了一个完整的单 元测试框架.
�
第章 异 常 处 理
在Java的测试过程,经常使用JUnit框架,它是一 个开放源代码产品,它支持测试开发,并提供运 行这些测试的环境.有关 JUnit 的详细信息,请 参见. 现在大多数Java集成开发工具都提供了对JUnit的 支持. 以NetBeans IDE为例.要生成一个JUnit测试项目, 只需要选择"工具"菜单中的"JUnit""创建测试 项目"即可.
6 异常处理
Java程序设计第6章异常处理第6章异常处理Java程序设计•本章介绍Java语言中的异常处理。
•6.1异常处理•6.2 自定义异常•6.3 断言及程序的测试•6.4 程序的调试Java程序设计异常处理••••••••••••••••••••••••••••••••••••••异常Java程序设计•异常(exception )又称为例外、差错、违例•对应着Java运行错误处理机制•基本写法•try{•语句组•}catch(Exception ex){•异常处理语句组;•}•示例:ExceptionForNum.java传统的语言如何处理Java程序设计•在一些传统的语言(如C语言中)☐if语句来判断是否出现了例外☐全程变量ErrNo•但这有几个缺点☐正常处理与异常处理的代码同样处理•可读性(readability)差☐每次调用一个方法时都进行错误检查•可维护性(maintainability )差☐错误由谁处理不请•职责不清Java中的异常处理Java程序设计•Java中处理异常☐抛出(throw)异常☐运行时系统在调用栈中查找•从生成异常的方法开始进行回溯,直到找到:☐捕获(catch)异常的代码相关的语句Java程序设计•抛出异常throw异常对象;•捕获异常•try{语句组}catch(异常类名异常形式参数名){异常处理语句组;}catch(异常类名异常形式参数名){异常处理语句组;}finally{异常处理语句组;}其中,catch语句可以0至多个,可以没有finally语句异常的分类Java程序设计•Throwable☐Error: JVM的错误☐Exception:异常•一般所说的异常•是指Exception及其子类Exception类Java程序设计•Exception类☐构造方法•public Exception();•public Exception(String message);•Exception(String message, Throwable cause) ;☐方法•getMessage()•getCause()•printStackTrace()多异常的处理Java程序设计•多异常的处理☐子类异常要排在父类异常的前面•finally语句☐无论是否有异常都要执行•即使其中有break,return等语句•在编译时,finally部分代码生成了多遍☐例TestTryFinally.java受检的异常Java程序设计•Exception分两种☐RuntimeException及其子类,可以不明确处理☐否则,称为受检的异常(checked Exception)•受检的异常,要求明确进行语法处理☐要么捕(catch)☐要么抛(throws):在方法的签名后面用throws xxxx来声明•在子类中,如果要覆盖父类的一个方法,若父类中的方法声明了throws异常,则子类的方法也可以throws异常•可以抛出子类异常(更具体的异常),但不能抛出更一般的异常•示例:ExceptionTrowsToOther.java再谈try…with…resourceJava程序设计•try(类型变量名= new 类型()){☐。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Java异常-抛出异常 • 在定义一个方法的时候,如果并不能确定如何处理其中可能出现 的异常,可以不在方法中对异常进行处理,而是将可能发生的异 常让这个方法的调用者来处理。 • 可以对下列情形在方法定义中抛出异常: • 方法中调用了一个会抛出“已检查异常”的方法。 • 程序运行过程中发生了错误,并且用throw子句抛出了一个 “已检查异常”。 • 如下实例 public static void main(String[] args) throws Exception,FileNotFoundException { File f = new File("c:/a.txt"); if (!f.exists())//如果文件不存在 { throw new FileNotFoundException("File can't be found!"); } }
•
Java异常处理机制 • Java程序的执行过程中如出现异常,会自动生成一个异常类对象, 该异常对象将被提交给Java运行时系统,这个过程称为抛出 (throw)异常。 • 当Java运行时系统接收到异常对象时,会寻找能处理这一异常的 代码并把当前异常对象交给其处理,这一过程称为捕获(catch) 异常。 • 如果Java运行时系统找不到可以捕获异常的方法,则运行时系统 将终止,相应的Java程序也将退出。 • 程序员通常只能处理违例(Exception)情况,而对错误(Error)情 况无能为力。
Java试听-异常卫昆来自Java异常• Java程序运行过程中所发生的异常事件可分为两类: • 错误(Error):JVM系统内部错误、资源耗尽等严重情况。 • 异常(Exception): 其它因编程错误或偶然的外在因素导致的一般性问题,例如: • 对负数开平方根 • 空指针访问 • 试图读取不存在的文件 • 网络连接中断 如下实例: public class ExceptionExam { public static void main(String args[]) { int a=100; int b=0; double c; c = a/b; System.out.println(a + "/" + b +" = "+c); } }
谢谢!
• finally:无论是否出现异常,程序最后都会执行该代码块中的内容。 • 以下实例:
public class ExceptionExam { public static void main(String args[]) { try{ int a=100; int b=0; double c; c = a/b; System.out.println(a + "/" + b +" = "+c); }catch(ArithmeticException e){ e.printStackTrace(); System.out.println("除数不能为零!"); }finally{ System.out.println("计算完毕!"); } } }
Java异常-常用异常类 • • • • • • • • • • • • 算术异常类:ArithmeticExecption 空指针异常类:NullPointerException 类型强制转换异常:ClassCastException 数组负下标异常:NegativeArrayException 数组下标越界异常:ArrayIndexOutOfBoundsException 违背安全原则异常:SecturityException 文件已结束异常:EOFException 文件未找到异常:FileNotFoundException 字符串转换为数字异常:NumberFormatException 操作数据库异常:SQLException 输入输出异常:IOException 方法未找到异常:NoSuchMethodException
Java异常-try-catch-finally
• try:将可能出现异常的代码或正常代码都放在try代码块中。 • catch :该句中捕获一个可能出现的异常。
• 一个try块可以和多个catch块配合以处理多个异常。 • 当try块内的任何代码抛出了由catch 子句指定的异常,则try代码端中的程序将会终 止执行,并跳到相应的catch代码块中来执行。
java异常-try-catch、throw、throws区别 • try-catch:对于觉得会有异常抛出的程序块,用try{}包住,然 后用catch来捕获该异常,并在catch中对异常做自行处理。 • throw:由于try-catch只能获取程序运行时引发的异常,而 throw语句可以引发明确的异常,程序运行到了throw语句这后就 立即停止,不会执行后面的程序。由于系统不能自行处理,只能 将异常抛给调用者。 • throws:如果一个方法会有异常,但你并不想处理这个异常,就 在方法名后面用throws,因此该异常就会被抛出,谁调用了这个 方法谁就要处理这个异常,或者继续向父类抛出。 • throw与throw的区别是: • throw 是语句抛出异常;throws 是方法抛出异常; • throws可以单独使用,但throw不能; • throw要么和try-catch-finally语句配套使用,要么与throws配套 使用。但throws可以单独使用,然后再由处理异常的方法捕获。 • throw是明确抛出异常,throws是有可能有这些异常被抛出。