第七章 Java中的异常(例外)
java异常处理机制
java异常处理机制
Java的异常处理是结构化编程的一个重要方面。
它提供了一种通用的方式来处理发生在应用程序或系统中的异常,比在代码中添加报错信息更有效。
Java异常处理模型包括异常类,异常处理器,throw和throws关键字以及堆栈跟踪。
异常类是Java的一种特殊类,它表示程序的异常状态(或者是错误情况)。
它从Java的Throwable类继承,Throwable类有两个子类,Exception和Error,它们派生出一组定义在Java中的异常。
异常处理器允许处理一个或多个特定类型的异常,是程序中处理异常的机制。
异常处理器通常作为程序的一部分,程序员可以通过编写异常处理器来为应用程序创建一个可以处理未知错误的安全环境。
Throw和throws关键字用于抛出异常。
Throw关键字用于将异常抛出到当前函数的调用点,throws关键字用于声明哪些异常可以被抛出,以便该方法的调用者可以捕获和处理它们。
堆栈跟踪是一种异常处理工具,可以展示异常期间应用程序运行的具体位置,同时可以追踪嵌套方法调用,并可以提供出现异常时的参数值,类型等等。
Java的异常处理机制为程序员提供了一种有效的处理在程序的运行过程中可能会发生的系统或应用程序异常的方法。
它可以保护应用程序免受非正常状况的危害,提高程序的安全性和效率。
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 之间的数字。
Java的异常处理机制
J v a a的异常处理相制
文。 周绮 ( 中国矿业大学计算机 学院 江苏徐 州)
盛
摘要 : 异常 处理 机制 是 J a语 言 的重 v a 要特 征 之一 ,合 理地 使 用异 常处 理 可 以在 很 大 程度 上提 高程 序 的安 全性 和 健 壮 性 。 文章 简单介绍 了J a的异常处理 机制 ,总 v a 结 了J a异常 处理 的方 式及使 用过程 中的 v a 注 意 事项 , 有一 定的 借 鉴 作 用 。 关键词 : a a; J V 异常处理 ; 异常类 引 言 异常 ,又称为例外 ,是指程 序运行过程 中发生 的非正常情 况的事件 ,比如 :除零溢 出、数组 越界 、内存溢 出等 ,这 些事件 的发 生将 阻止程序 的正常运行 。传统 的编程语 言 没有异 常处理机 制 ,处理 错误完 全依靠程序 员,通 常是遇到 错误返 回一个特殊 的值或者 设 定一 个 标 志 ,并 以 此 判断 是 否 有错 误 产 生 ,这给程序维护带来 了很大 的障碍 。J a v a 利 用面 向对象 的方法 ,把 异 常处 理固化 到语 言 中,并把各种 不同异 常分类 ,同时提 供了 良好的接 I 。这种处理机 制 为复杂程序提 供 : 1 了强有力的控 制方式 ,同时这 些异常代 码与 “ 常规”代码 的分离 ,增加 了程 序的可读 性 , 编 写程 序时 也显 得更 为 灵活 。 由于 J v a a语言 中的异常处理和 J va运 a 行 时 系统 相 关 ,它消 耗 内 存和 处 理 器来 处 理 创 建 、抛 出 、捕 获 、处理 异 常 ,如果 不 能合 理 使用 就 会适 得 其 反 , 降低 软 件 的可 读 性 和 执 行 效 率 。 本 文 首 先 简 单 介 绍 了 Jv a a的异常处理机制 ,然后就 J v a a语言的 异常 处 理方 法 及 使用 过 程 中 的注 意事 项 进 行 了总 结 。 二、J a异常处 理机制 v a J va用 面向对象 的方法处 理异常 ,任 a 何一个异常都 是一个对象 。 如图 l所示 ,所 有 异常类的根类是 Thr owa l b e类 ,它派生 出 E r r E c p i n两个基本子类。其中 ro 和 x e t o E r r0r代表编 译时和 系统错 误 ,一 般这类 异常 是 不可 修 复 、 不 易处 理 的 ,一 般 不用 程序员处理 。而 EXC t 0 eP i n代表的异 常可 以 被捕 获 处 理 , 它包 括 Run i E e to tme xc p i n 和 一 般 异常 。
Java程序设计课件:异常处理
将异常组织成一个对象树结构,有利于保持方法定义的稳定性, 同时也给方法的使用者提供了以不同粒度处理异常的自由。
17/22 2023/12/28
7.3 自定义异常
Java程序设计
异常处理
本章主要内容
异常的概念 处理异常 自定义异常 小结
2023/12/28
2/22
异常的概念
凡是在运行时进入的不正常状态都称为错误。 这些错误根据错误的严重性可以分为两类:
一类是致命性的错误,它们的出现可能会导致系 统崩溃,并且程序员并不能编写程序解决所出现 的问题;
非法访问异常,如试图访问非公有方法。
实例化异常,如实例化抽象类。 中断异常。 输入输出异常。
找不到指定的字段异常。
找不到指定方法异常。
打印机错误报告异常。 运行时异常。 SQL语句执行错误异常。 线程阻塞超时异常。 执行转换算法异常。
2023/12/28
7/22
常见的RuntimeException类的子类
2. 抛出的异常对象如果属于 catch括号中要捕获的异常类 ,则catch会捕获此异常,且 为该异常创建一个引用名,然 后执行catch程序块中的异常 处理程序。其中“……”表示 多个catch程序块,每个catch 程序块捕获一种异常。
3. 无论try程序块是否捕获到 异常,或者捕获到的异常是否 与catch() 括号内的异常类型 相同,最后一定会运行finally 块里的程序代码。
} }
11/22 2023/12/28
异常捕获策略
尽可能只捕获指定的异常,而不是捕获多个异常的公共父 类,除非确信这个异常的所有子类对程序来说是没有差别 的,可以同样的方式来处理它们,同时也要考虑该异常将 来可能的扩展。只要有可能,就不要捕获 ng.Exception或ng.Throwable。
java异常处理方法及流程
java异常处理方法及流程Java 异常处理方法及在 Java 编程中,异常处理是一项非常重要的技术。
通过适当的异常处理方法,可以使程序具备更好的稳定性和可读性,提高程序的健壮性。
本文将详细介绍 Java 异常处理的各个流程。
异常的基本概念异常是在程序执行期间产生的一种错误或异常情况。
Java 引入了异常处理机制来处理这些异常,以提高程序的可靠性和可维护性。
异常分为两种类型:1.受检异常(Checked Exceptions):受检异常在编译阶段必须进行处理,否则编译器将报错。
例如,IOException 是常见的受检异常。
2.非受检异常(Unchecked Exceptions):非受检异常是指不需要显式捕获或声明抛出的异常,编译器不会检查是否对其进行处理。
例如,NullPointerException 是常见的非受检异常。
异常处理的方法Java 提供了多种处理异常的方法,包括捕获异常和抛出异常。
下面分别进行介绍。
捕获异常是指通过使用try-catch语句块来捕获并处理异常。
try语句块用于包裹可能出现异常的代码,catch语句块用于捕获并处理异常。
try {// 可能抛出异常的代码块// ...} catch (ExceptionType1 e1) {// 处理异常类型1// ...} catch (ExceptionType2 e2) {// 处理异常类型2// ...} finally {// 可选的 finally 代码块,始终会被执行// ...}抛出异常当一个方法无法处理某个异常时,可以通过throw关键字手动抛出异常。
异常将会被传递给调用该方法的代码,并进一步处理。
public void someMethod() throws SomeException {if (someCondition) {throw new SomeException("Some error message");}使用异常的注意事项在使用异常处理时,需要注意以下几点:•捕获异常的顺序非常重要,应该从特定异常到一般异常的顺序进行捕获。
Java开发中的常见错误及解决方法
Java开发中的常见错误及解决方法在Java开发中,开发者可能会遇到许多常见的错误。
这些错误可能来自于语法错误、逻辑错误或者编码风格等不同的方面。
今天,我们就来一起探讨Java开发中常见的错误以及如何解决这些问题。
一、空指针异常(NullPointerException)空指针异常是一个极为常见的错误,很容易发生。
这个错误通常发生在访问一个空对象或者调用一个空对象的方法时发生。
在Java中,如果变量没有被初始化或者设置为null,其值就为空。
解决方案:1. 检查变量是否被正确初始化或者设置为null;2. 使用if判空语句来避免空指针异常的发生;3. 使用Objects类中的requireNonNull方法,可以在变量为空的时候抛出异常,防止出现空指针异常的情况,例如:public void showData(String data){Objects.requireNonNull(data,"data must not be null");//do something...}二、数组越界异常(ArrayIndexOutOfBoundsException)如果在访问数组时访问了数组的不存在的元素,或者使用负数的下标来访问数组,就会抛出数组越界异常。
对于数组的访问,必须保证数组下标越界。
解决方案:1. 检查数组下标是否越界;2. 尽可能使用for-each循环,可以保证不会越界;三、类型转换异常(ClassCastException)类型转换异常是因为试图将一个对象转换为不相关的对象类型而导致的异常。
在Java中,如果试图将一个子类实例转换为父类对象时,不需要进行任何显式的类型转换操作。
但是,将一个父类实例转换为一个子类时,就需要使用强制类型转换操作。
解决方案:1. 确保转换类型之前,先用instanceof判断对象类型;2. 避免在不相关对象类型之间进行强制类型转换操作;四、算术异常(ArithmeticException)算术异常通常发生在程序试图除以0的情况下。
java中常见的五种异常
java中常见的五种异常
1.ClassCastException(类转换异常)
数据类型转换错误,比如有个String temp="abc"; 如果设为(int)temp就会报错了,因为它们类型不一样,但是设为(object)temp就可以,因为object是它们的父类
2.IndexOutOfBoundsException(数组越界)
这个异常我们在操作数组的时候会经常遇到,异常的解释是“数组下标越界“,现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。
3.NullPointerException(空指针)
这个异常在编程时也经常遇到,异常的解释是“程序遇上了空指针“,简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在调用数组这些操作中,对数组操作中出现空指针,很多情况下是一些刚开始学习编程的人常犯的错误,即把数组。
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的异常处理机制名词解释
java的异常处理机制名词解释在Java开发过程中,异常处理机制是一项重要的功能。
它允许我们在程序中正确处理异常情况,使程序能够更加健壮。
本文将围绕Java的异常处理机制展开,逐步分析其中的名词解释。
1. 异常在Java中,异常指的是在程序执行过程中发生的一些错误或不正常的情况。
这些情况可能是由于用户输入的不正确或系统资源不足等原因所导致。
当程序发生异常时,程序流程将会被中断并转入异常处理程序进行处理。
2. 异常分类Java中的异常分为两类:受检异常和非受检异常。
受检异常是在编译期就可以检测到的异常,编译器强制要求程序去处理这些异常。
而非受检异常不需要强制要求程序去处理,通常是由程序逻辑错误引起的。
3. 异常处理器异常处理器是一段特殊的程序,用于捕获并处理异常。
在Java 中,异常处理器通常使用try-catch语句块来实现。
当程序执行到try 语句块时发生异常,程序将转入catch语句块并进行异常处理。
4. 抛出异常当程序执行发生异常时,可以使用throw语句抛出异常。
throw 语句通常包括一个异常对象,用于说明发生的异常类型。
5. 自定义异常在Java中,我们可以自定义异常来处理我们自己的异常情况。
自定义异常需要继承自Exception类或者RuntimeException类。
通过自定义异常,我们可以将一些通用的异常情况封装起来,提高程序的可读性和可维护性。
6. finally块finally块是try-catch语句块的可选部分,用于在无论是否发生异常都要执行的代码。
finally块通常用于释放资源或进行清理操作。
7. try-with-resources语句try-with-resources语句是Java 7中新增的语法,用于自动关闭资源。
这种语句会自动将在try语句块中声明的资源关闭,无需手动关闭。
这在程序中可以简化代码,提高程序的可读性和可维护性。
通过以上分步骤阐述,我们深入了解了Java的异常处理机制,并对其中的名词解释有了更加清晰的认识。
Java常见异常(RuntimeException)详细介绍并总结
Java常见异常(RuntimeException)详细介绍并总结本⽂重在Java中异常机制的⼀些概念。
写本⽂的⽬的在于⽅便我很长时间后若是忘了这些东西可以通过这篇⽂章迅速回忆起来。
1. 异常机制1.1 异常机制是指当程序出现错误后,程序如何处理。
具体来说,异常机制提供了程序退出的安全通道。
当出现错误后,程序执⾏的流程发⽣改变,程序的控制权转移到异常处理器。
1.2 传统的处理异常的办法是,函数返回⼀个特殊的结果来表⽰出现异常(通常这个特殊结果是⼤家约定俗称的),调⽤该函数的程序负责检查并分析函数返回的结果。
这样做有如下的弊端:例如函数返回-1代表出现异常,但是如果函数确实要返回-1这个正确的值时就会出现混淆;可读性降低,将程序代码与处理异常的代码混爹在⼀起;由调⽤函数的程序来分析错误,这就要求客户程序员对库函数有很深的了解。
1.3 异常处理的流程1.3.1 遇到错误,⽅法⽴即结束,并不返回⼀个值;同时,抛出⼀个异常对象1.3.2 调⽤该⽅法的程序也不会继续执⾏下去,⽽是搜索⼀个可以处理该异常的异常处理器,并执⾏其中的代码2 异常的分类2.1 异常的分类2.1.1 异常的继承结构:基类为Throwable,Error和Exception继承Throwable,RuntimeException和IOException等继承Exception,具体的RuntimeException继承RuntimeException。
2.1.2 Error和RuntimeException及其⼦类成为未检查异常(unchecked),其它异常成为已检查异常(checked)。
2.2 每个类型的异常的特点2.2.1 Error体系 Error类体系描述了Java运⾏系统中的内部错误以及资源耗尽的情形。
应⽤程序不应该抛出这种类型的对象(⼀般是由虚拟机抛出)。
如果出现这种错误,除了尽⼒使程序安全退出外,在其他⽅⾯是⽆能为⼒的。
java异常解决方案
java异常解决方案一、Hibernate(1)org.hibernate.TransientObjectException: object references an unsaved transient instance....(2)org.springframework.orm.hibernate3.HibernateSystemException: Don't change the reference to a collection withcascade="all-delete-orphan": entity.Klass.students; nested exception is org.hibernate.HibernateException: Don't change the reference to a collection with cascade="all-delete-orphan": entity.Klass.students二、Tomcat(1)tomcat启动时报错:java.io.EOFException(2)tomcat内存溢出三、JAVA基本(1)ng.ClassCastException:(2)ng.UnsupportedClassVersionError: Bad version number in .class file四、JSP(1)javax.servlet.jsp.JspException:(2)org.apache.jasper.JasperException: Unable to compile class for JSP:(3)Servlet.service() for servlet jsp threw exceptionng.Error: Unresolved compilation problem:(4)ng.Error: Unresolved compilation problem:The method contextInitialized(ServletContextEvent) of type CreateDataSourceTableListener must override a superclass method(5)Servlet.service() for servlet jsp threw exception ng.Error: Unresolved compilation problem:The method setCharacterEncoding(String) is undefined for the type ServletResponse五、SSH整合(1)ng.ClassNotFoundException:org.springframework.web.context.ContextLoaderListener(2)Exception starting filter struts2 Class:com.opensymphony.xwork2.spring.SpringObjectFactory File: SpringObjectFactory.java Method: getClassInstance(3)(7)(8)org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'biz' defined in class path... (4)Exception starting filter struts2The action name cannot be the same as the action suffix [Action] - Class: org.apache.struts2.convention.SEOActionNameBuilder (5)avax.management.RuntimeErrorException: Error thrown in preDeregister methodCaused by: ng.NoClassDefFoundError:org/apache/struts2/util/ObjectFactoryDestroyable(6)Unable to load configuration. - bean -jar:file:/D:/Tomcat/tomcat/apache-tomcat-6.0.30/webapps/tes t/WEB-INF/lib/struts2-core-2.2.3.1.jar!/struts-default.xml: 29:72六、Struts(1)ng.NoSuchMethodException:action.StudentAction.getAllStudent()(2)Caused by: ng.ClassCastException:org.apache.xerces.parsers.XML11Configuration cannot be cast to org.apache.xerces.xni.parser.XMLParserConfiguration (3)No result defined for action and result七、Android(1)There is no android project named 'cm-android'一、Hibernate一(1)org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: er某个对象的某个属性是一个实体,在这个实体没有保存之前就保存这个对象而造成了这个错误。
Java运行时异常和非运行时异常
Java运⾏时异常和⾮运⾏时异常1.异常机制Java把异常当做对象来处理,并定义⼀个基类ng.Throwable作为所有异常的超类。
Java中的异常分为两⼤类:错误Error和异常Exception,Java异常体系结构如下图所⽰:2.ThrowableThrowable类是所有异常或错误的超类,它有两个⼦类:Error和Exception,分别表⽰错误和异常。
其中异常Exception分为运⾏时异常(RuntimeException)和⾮运⾏时异常,也称之为不检查异常(Unchecked Exception)和检查异常(Checked Exception)。
3.Error⼀般是指java虚拟机相关的问题,如系统崩溃、虚拟机出错误、动态链接失败等,这种错误⽆法恢复或不可能捕获,将导致应⽤程序中断,通常应⽤程序⽆法处理这些错误,因此应⽤程序不应该捕获Error对象,也⽆须在其throws⼦句中声明该⽅法抛出任何Error或其⼦类。
4.可查异常和不可查异常通常,Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。
可查异常(编译器要求必须处置的异常):正确的程序在运⾏中,很容易出现的、情理可容的异常状况。
可查异常虽然是异常状况,但在⼀定程度上它的发⽣是可以预计的,⽽且⼀旦发⽣这种异常状况,就必须采取某种⽅式进⾏处理。
除了RuntimeException及其⼦类以外,其他的Exception类及其⼦类都属于可查异常。
这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么⽤try-catch语句捕获它,要么⽤throws⼦句声明抛出它,否则编译不会通过。
不可查异常(编译器不要求强制处置的异常):包括运⾏时异常(RuntimeException与其⼦类)和错误(Error)。
Java中异常的概念和分类
Java中异常的概念和分类
异常就是程序在编译时发⽣的意想不到的情况,⼀般⽽⾔分为两类:错误(Error)和异常(Exception)
Error: 分为两种:
程序编写出现语法错误
Exception: 所有异常类的⽗类(我们说的异常处理⼀般就是处理与Exception类相关的异常,Exception和Error合起来被称作异常,但Exception⾃⾝也可以被称为异常,通常我们说的异常指的就是Exception及其⼦类
Exception异常分为编译时异常和运⾏时异常,由于我们⽆法预测程序⾥可能出现的错误或⽤户在使⽤程序时会出现的错误,所以需要异常类来告诉我们程序出现了异常,⽐如0不能作为除数,但⽤户硬是⽤做了除数怎么办?
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();
System.out.println(1/a);
}
Exception的⼦类被分为两⼤类:编译时异常,运⾏时异常
编译时异常: 在编写代码时如果有此类异常则必须被捕获(catch)或抛出(throw)
运⾏时异常: 可以不必再编写代码时捕获或抛出
说明: 所有异常都可以被捕获或抛出,如果异常最终没有被捕获⽽是被抛出的话程序会⽴即终⽌运⾏并打印异常信息,另外,如果不捕获运⾏时异常,默认会抛出运⾏时异常
编译时异常的特征: 直接继承⾃Exception类,不继承RuntimeException,必须被显式的捕获或抛出
运⾏时异常的特征: 继承⾃RuntimeException类,可以不被显式的捕获或抛出,如果不被显式的捕获则默认会被抛出。
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. 异常并不能解决所有问题。
简述java中的异常处理机制
简述java中的异常处理机制一、概述Java是一种面向对象的编程语言,其异常处理机制是其核心特性之一。
Java的异常处理机制可以让程序员在代码中处理预期和未预期的错误情况,从而提高程序的稳定性和可靠性。
二、异常分类Java中的异常分为两类:受检异常(checked exception)和非受检异常(unchecked exception)。
1. 受检异常受检异常是指在编译时就能够被捕获到的异常,必须要进行处理。
这些异常通常是由于外部环境或用户输入导致的,例如文件不存在、网络连接失败等。
2. 非受检异常非受检异常是指在运行时才能够被捕获到的异常,不需要进行处理。
这些异常通常是由于程序逻辑错误或内存问题导致的,例如空指针引用、数组下标越界等。
三、Exception类及其子类Java中所有的异常都继承自Exception类或RuntimeException类。
其中Exception类包括了所有受检异常,而RuntimeException类包括了所有非受检异常。
1. Exception类Exception类包括了许多子类,如IOException、SQLException等。
这些子类都需要在方法声明中使用throws关键字进行声明或使用try-catch语句进行捕获和处理。
2. RuntimeException类RuntimeException类包括了许多子类,如NullPointerException、ArrayIndexOutOfBoundsException等。
这些子类可以在方法中直接抛出,不需要进行声明或捕获处理。
四、异常处理方式Java中有两种异常处理方式:try-catch语句和throws关键字。
1. try-catch语句try-catch语句用于捕获异常并进行处理。
其基本语法如下:```try {// 可能会抛出异常的代码} catch (ExceptionType e) {// 异常处理代码}```其中,ExceptionType指的是要捕获的异常类型,可以是任何Exception类或其子类。
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中的异常处理机制
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语句块。
JAVA常见异常解析
JAVA常见异常解析--xyyan1. ng.nullpointerexception这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等。
对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了。
数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的,所以还需要对每个元素都进行初始化(如果要调用的话)2. ng.classnotfoundexception这个异常是很多原本在jb等开发环境中开发的程序员,把jb下的程序包放在wtk下编译经常出现的问题,异常的解释是"指定的类不存在",这里主要考虑一下类的名称和路径是否正确即可,如果是在jb下做的程序包,一般都是默认加上package的,所以转到wtk下后要注意把package的路径加上。
3. ng.arithmeticexception这个异常的解释是"数学运算异常",比如程序中出现了除以零这样的运算就会出这样的异常,对这种异常,大家就要好好检查一下自己程序中涉及到数学运算的地方,公式是不是有不妥了。
4. ng.arrayindexoutofboundsexception这个异常相信很多朋友也经常遇到过,异常的解释是"数组下标越界",现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。
第7章__例外处理
throw e;
throws Etype1, Etype2 ……
1、例外的概念
程序中的例外不外乎两种情况:一种是运行环境不能 满足程序运行的要求而出错;一种是程序要解决的问 题的约束而导致的。 不管是哪种情况,编写程序时,程序员要考虑到程序 运行时可能遇到的各种情况(条件),并进行处理; 如果不能处理,或者不知该如何处理,就可以认为是 一种错误,这时,就需要交给别人去处理。 以前,是通过返回错误代码来提示别人程序有错误; 在Java中,则是通过例外机制通知别人出错信息。
1、例外的概念
{
用例外的形式处理错误:
try { openTheFile; determine its size; allocate that much memory; read-File; closeTheFile; } catch(fileopenFailed) catch(sizeDetermineFailed) catch(memoryAllocateFailed) catch(readFailed) catch(fileCloseFailed) finally
Exception:一般程序中可预知的问题,其产生的例外 可能会带来意想不到的结果,因此Java编译器要求Java 程序必须捕获或声明所有的非运行时异常。
2、例外的分类
用户自己产生的例外
Throwable
Exception
处理
Error
不做处理 由用户捕获或 声明并处理 RuntimeException
AWTError (in java.awt) …
2、例外的分类
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 语句用于捕获异常并进行处理。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
2.程序设计中的三种错误 程序设计中的三种错误---语法错误(编译时的 程序设计中的三种错误 错误)、逻辑错误(运行时的错误)、异常错 误(运行时的错误)。 3.异常错误的特点:程序在运行过程中所发生的 .异常错误的特点: 错误事件;程序员在编程时无法预知它是否会 产生;产生与否取决于用户当时的执行环境。
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
2、声明所抛出的异常
声明抛出异常 如果在一个方法中生成了一个异常,但是这一方 法并不确切地知道该如何对这一异常事件进行处理, 这时,一个方法就应该声明抛弃异常,使得异常对象 可以从调用栈向后传播,直到有合适的方法捕获它为 止。 声明抛弃异常是在一个方法声明中的throws子句 中指明的。
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
7.2异常处理
(1)由系统自动处理。 (2)通过 通过try、catch、finally语句块,捕获住该异 语句块, 通过 、 、 语句块 Java 常 。这是积极的异常处理机制。如果Java运行时系统找不到可以捕获异常的
方法,则运行时系统将终止,相应的Java程序也将退
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
2.抛出异常: 抛出异常: 抛出异常 系统中定义的异常时 1>系统自动抛出的异常(程序中出现系统中定义的异常时 系统中定义的异常时,可以由 系统自动抛出)。 2>对于在函数定义时采用throws声明所不处理的异常类型时,在 其函数体中必须使用“throw 异常事件(对象名)” 来抛出 该种类型的异常事件(程序员自己抛出程序中定义的自己的异 程序员自己抛出程序中定义的自己的异 常事件),以便上一级的调用者来捕获并处理它。 常事件 例如: IOException e=new IOException(); throw e ; 可以抛出的异常必须是Throwable或其子类的实例。下面 的语句在编译时将会产生语法错误: throw new String("want to throw"); ExceptionDemo2.java
异常的抛 出
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
3、声明和抛出异常 声明和抛出异常
1.异常声明:在可能会出现异常的函数声明中给出异常 异常声明: 异常声明 定义。 定义的格式: 返回类型 函数名(形参定义)throws 定义的异 常事件类型列表(类名) { 函数体定义; } 注 : 当某一个函数本身不处理某些异常时,也可在 定义该函数时可预先说明(声明)该函数不处理的 异常类型。
public class Inheriting { public static void f( ) throws MyException { System.out.println("Throwing MyException from f()"); throw new MyException(); //抛出自定义异常 } ……… public static void main(String[] args) { try { f(); } //处理自定义异常 catch(MyException e) { e.printStackTrace(); } ……… } //end of main() } //end of class Inheriting
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
7.1 什么是异常 7.2 异常的处理 7.3 自定义异常类的使用
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
7.1 什么是异常
含义: 含义:异常(Exception)是程序在运行过程中所发生的非正常事 件 (而这些错误在设计时不能准确地识别出但又可能 会发生或者不会发生。
(3)使用throw语句直接抛出异常或使用throws语句 间接抛出异常。(这可通过throws语句来声明所抛出 的异常 )
如果一个方法并不知道如何处理所出现的异常,则可在方法声明时,声明抛弃 (throws)异常。这是一种消极的异常处理机制。
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
多catch语句块编程要点: ① catch 语 句 的 顺 序 : 捕获异常的顺序和catch语句的顺序有关,当捕获 到一个异常时,剩下的catch语句就不再进行匹配。因 此,在安排catch语句的顺序时,首先应该捕获最特殊 的异常,然后再逐渐一般化。也就是一般先安排子类, 再安排父类。 ② try 与catch之间不能有其他语句(不能隔断)。 try { } int x=1; catch(Exception e) { }
可以捕获异常的方法,则运行时系统将终止,相应的Java程序也将退出。
中的异常(例外过程: 出现异常事件时,Java系统自动产生一个异常对 象,然后将这个对象传递给Java运行时系统,这个 例外产生和提交的过程称为抛出(throw)异常 ( Exception );当Java运行时系统得到例外对象 以后,它将会寻找处理这一例外的代码,找到能处 理这一例外的方法以后,运行时系统把当前例外对 象交给这个方法进行处理,这一过程称为捕获 (catch)异常( Exception ) 。
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
2、异常处理机制
Java的异常处理机制:抛出异常并捕获异常。 的异常处理机制: 的异常处理机制 1.抛出异常 : 当程序中产生异常时,运行系 抛出异常: 抛出异常 统将抛出异常类对象(它代表某一异常类型的 错误)。 2.捕获异常:用户程序或运行系统可以捕获该异 捕获异常: 捕获异常 常类对象(在函数的调用栈中查找能处理此异 常事件的程序为止)并相应地给出处理的方法 (代码)。这是积极的异常处理机制。如果Java运行时系统找不到
也就是说不捕获和处理该异常, 也就是说不捕获和处理该异常,但但必须继 续上传(递交给上一级的调用者来处理),
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
import java.io.*; //实例二 实例二 class ExceptionDemo2 { public static void main(String args[]) throws Exception 继续声明(继续上传) 异常的声明 { int Value=1; 异常的声明 compute(Value); Value=20; compute(Value); } static void compute(int a) throws Exception { if(a >10) throw new Exception(); System.out.println("Normal Exit"); } } //异常的
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
7.3 自定义异常类的使用
注意: 注意 : 声明自己的异常类的主要目的是为应用程序中特 定错误提供相应的错误提示信息,而不便采用标准的 错误信息(扩充 扩充Java系统中的异常类 系统中的异常类)。 扩充 系统中的异常类 编程要求: 编程要求: ( (1)声明一个新的异常类,该异常类必须从Java已有 定义的异常类继承,如Exception、IOException等 (2)为新的异常类定义属性和方法,或重载父类的属性 和方法,使这些属性和方法能够体现该类所对应的错 误的信息。
……
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
import java.io.*; class ExceptionDemo { public static void main(String args[]) { FileInputStream fis=new FileInputStream(“text”); int b; while((b=fis.read())!= -1) { System.out.println(b); } fis.close(); } }
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
3、异常类的层次和主要子类
在jdk中,每个包中都定义了异常类,而所有的异常类都直接或间接地继承于 Throwable类。 java中的异常类可分为两大类:(它们均被放在ng包中) Error: 动态链接失败,虚拟机错误等,通常Java程序不应该捕获这类异 常,也不会抛弃这种异常。 Exception 1)运行时异常: 继承于RuntimeException的类都属于运行时异常,例如算术异常 (除零错)、数组下标越界异常等等。由于这些异常产生的位置是未知的, Java 编译器允许程序员在程序中不对它们做出处理。 2)非运行时异常: 除了运行时异常之外的其他由Exception 继承来的异常类都是非运行 时的异常,例如FileNotFoundException(文件未找到异常)。Java编 译器要求在程序中必须处理这种异常,捕获异常或者声明抛弃异常。 异常类的方法和属性(祥见类库)
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
class MyException extends Exception { //自定义异常 public MyException() {} public MyException(String msg) { super(msg); } }
中的异常(例外 第 七 章 Java中的异常 例外 中的异常 例外)
finally: finally:它指定一代码块,不管是否有异常产生或是否捕 获住该异常,程序都从此处继续向后执行。从而达到提 供统一的出口(如关闭文件、清除系统资等)。 finally { if(fis !=null) { System.out.println(“Closing file…”); fis.close(); } else { System.out.println(“FileInputStream not Open !”); } }