JAVA异常及其分类
Java异常面试题 33道
Java异常架构与异常关键字1. Java异常简介Java异常是Java提供的一种识别及响应错误的一致性机制。
Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。
在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪”抛出，异常信息回答了“为什么”会抛出。
2. Java异常架构1. ThrowableThrowable 是 Java 语言中所有错误与异常的超类。
Throwable 包含两个子类：Error（错误）和 Exception（异常），它们通常用于指示发生了异常情况。
Throwable 包含了其线程创建时线程执行堆栈的快照，它提供了 printStackTrace() 等接口用于获取堆栈跟踪数据等信息。
2. Error（错误）定义：Error 类及其子类。
程序中无法处理的错误，表示运行应用程序中出现了严重的错误。
特点：此类错误一般表示代码运行时 JVM 出现问题。
通常有 Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。
比如 OutOfMemoryError：内存不足错误；StackOverflowError：栈溢出错误。
此类错误发生时，JVM 将终止线程。
这些错误是不受检异常，非代码性错误。
因此，当此类错误发生时，应用程序不应该去处理此类错误。
按照Java惯例，我们是不应该实现任何新的Error子类的！3. Exception（异常）程序本身可以捕获并且可以处理的异常。
Exception 这种异常又分为两类：运行时异常和编译时异常。
运行时异常定义：RuntimeException 类及其子类，表示 JVM 在运行期间可能出现的异常。
特点：Java 编译器不会检查它。
也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。
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常见异常（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运⾏系统中的内部错误以及资源耗尽的情形。
应⽤程序不应该抛出这种类型的对象（⼀般是由虚拟机抛出）。
如果出现这种错误，除了尽⼒使程序安全退出外，在其他⽅⾯是⽆能为⼒的。
java2实用教程第六版知识点汇总
Java2实用教程第六版知识点汇总1.引言本文档旨在对Ja va2实用教程第六版涉及的主要知识点进行全面的汇总和总结。
通过学习该教程，读者将能够全面掌握Ja va2编程的核心概念和技巧，为日后的J av a开发工作打下坚实的基础。
2.数据类型J a va2实用教程第六版详细介绍了Ja va中的各种数据类型及其使用方法。
以下是一些关键的知识点：2.1基本数据类型J a va的基本数据类型包括整型、浮点型、字符型和布尔型。
本教程提供了详细的介绍和示例代码，帮助读者理解这些数据类型的特点和用法。
2.2引用数据类型除了基本数据类型外，J av a还提供了多种引用数据类型，如数组、类、接口等。
教程中的例子演示了如何声明和使用这些引用数据类型，帮助读者熟悉它们的基本概念和操作。
3.控制流程控制流程是编程中的重要概念，决定了程序的执行顺序和逻辑。
J a va2实用教程第六版涵盖了常见的控制流程语句，包括条件语句和循环语句。
3.1条件语句条件语句用于根据条件的真假来选择性地执行不同的代码块。
本教程提供了i f语句、swi t ch语句等条件语句的详细说明和示例，让读者明白如何正确运用它们。
3.2循环语句循环语句用于重复执行某段代码，直到满足退出条件为止。
Ja v a2实用教程第六版介绍了三种循环语句：f or循环、w hi le循环和d o-wh il e循环。
读者将学会如何正确选择和使用不同类型的循环语句，以解决各种实际问题。
4.类与对象面向对象编程是J ava的核心思想之一。
J a va2实用教程第六版详细讲解了类与对象的概念、属性和方法的定义与使用等内容。
4.1类的定义与使用教程中提供了清晰的例子，介绍了如何定义类、声明对象、调用类的方法等操作。
读者将了解到如何通过类和对象来构建复杂的应用程序。
4.2构造方法与析构方法构造方法用于在创建对象时进行初始化操作，而析构方法则在对象销毁时执行清理工作。
本教程详细说明了构造方法和析构方法的特点和使用方法，帮助读者正确地管理对象的生命周期。
Java异常处理技术及应用
浅谈Java异常处理技术及应用摘要：随着系统规模的不断扩大，传统的异常处理技术已经成为创建大型可维护程序的障碍了。
java是一种面向对象的程序设计语言，java的异常处理非常出色。
java把异常封装到类里，运用“try/catch/finally”异常处理机制，最终得到的是更为“健壮”的异常处理代码。
关键字：异常处理 java应用一、前言异常是在程序运行过程中发生的非正常事件。
比如：除零溢出、数组越界、内存溢出等。
这些事件的发生将阻止程序的正常运行。
为了加强程序的健壮性，程序设计时，必须考虑到可能发生的异常事件并做相应的处理。
传统的错误处理方法一般以判断返回值的方式处理错误，使得正常程序代码和错误代码混合在一起，给程序维护带来很大的障碍。
java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，据有良好的层次性。
这种异常处理机制能将处理错误异常的代码和“常规”代码分开，使程序维护起来更加方便，同时也增强了程序的安全性和健壮性。
和java语言的其它特性相比，异常处理显得深奥且不易掌握。
因为它和java运行时系统密切相关，本文着重就java语言的异常处理机制及在程序设计中的应用作一个初步的探讨。
二、异常类的结构及组成java中的throwable（抛出）类是一个专门处理异常的类。
它派生了两个子类：error（出错）类和exception（异常）类。
error 类对象是由java虚拟机生成并抛出给系统。
通常，java 程序不对错误进行处理；exception 类对象是java程序抛出和处理的对象。
它又分为runtimeexception（运行期间异常）、awt ex-ception（awt 异常）和io exception（输入输出异常），这三种子类分别对应于不同类型的异常。
另外，用户根据需要可以自己定义异常类。
三、异常的处理1、处理机制java 中使用异常类及其子类对程序出现的各种异常事件给出了一个统一的、简单的抛出错误和处理错误的机制，可以概括为以下几个过程：（1）在java程序的执行过程中，如果出现了一个可识别的的错误，则会生成一个与该错误相对应的异常类对象，该对象将被提交给运行时的系统，这个过程称为抛出（throw）异常。
简述java中异常处理机制的流程。
Java是一种面向对象的编程语言，所以在编写Java程序时需要考虑异常处理。
异常是指在程序运行过程中出现的错误、故障或意外情况，而异常处理机制则是为了保证程序在遇到异常时能够正确、有效地进行处理，确保程序的稳定性和安全性。
1. 异常的分类在Java中，异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。
受检异常是指在编译期就能够被检测到的异常，需要进行显式的处理；非受检异常则是指在运行期才能被检测到的异常，通常是由程序错误造成的，需要进行相应的处理。
2. 异常处理机制的流程在Java中，异常处理机制主要涉及到try、catch、finally和throw关键字的使用。
(1) try块：在try块中编写可能会引发异常的代码。
如果在try块中出现了异常，程序会立即跳转到catch块进行相应的异常处理。
(2) catch块：在catch块中定义对异常的处理逻辑。
在catch块中可以针对不同类型的异常编写不同的处理代码，也可以进行异常的记录、打印或其他操作。
(3) finally块：finally块中的代码无论是否出现异常都会被执行。
通常在finally块中释放资源、关闭文件等清理工作。
(4) throw关键字：throw关键字用于手动抛出一个异常。
当程序中的某个条件不满足时，可以使用throw关键字抛出一个异常，然后交由catch块进行处理。
3. 异常处理机制的应用在实际的Java编程中，异常处理机制是非常重要的。
通过合理地编写异常处理代码，可以提高程序的容错性和稳定性，保证程序在面对异常时能够优雅地处理并继续执行。
另外，Java中还提供了一些与异常相关的类，例如Throwable、Exception和RuntimeException等，开发人员可以根据实际需求选择合适的异常类来进行处理。
异常处理机制是Java程序设计中不可或缺的重要部分，合理并且规范地使用异常处理机制能够提高程序的可靠性和稳定性，也能让程序更加健壮。
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异常处理机制
JAVA异常处理机制摘要：在编写java程序时，应尽可能避免异常的发生；在异常发生时提供处理这些不正常事件的方法，使程序不会因为异常的发生而中断或产生不可预见的结果。
该文阐述如何运用java的异常处理机制为我们控制和处理异常的出现，从而保证程序的安全性和可用性。
关键词： java；异常；异常处理；继承中图分类号：tp311 文献标识码：a 文章编号：1009-3044（2013）15-3525-02异常是程序在运行期发生的不正常的事件，它会打断指令的正常执行流程。
例如：整数除以零、使用空指针、数组越界访问、文件找不到、用户输入错误、格式不正确的url、连接数据库失败等等。
异常不同于编译错误，编译错误是因为程序存在语法问题而未通过编译，异常其实相当于运行错误，也就是在程序的运行中出现一些没有预料到的情况或不能人为控制的因素，这时就需要进行异常处理。
1 异常的处理机制异常产生的位置是在方法内部。
我们只会说，一个方法产生了异常，而不是一个类或一个变量产生了异常。
java程序在执行过程中如果某个方法内出现异常，会自动生成一个异常类的对象（throwable），该异常对象将被自动提交给jvm，这个过程称之为抛出（throw）异常[1]。
异常抛出之后，jvm会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称之为捕获（catch）异常和处理异常。
如果jvm找不到可以捕获异常的代码，jvm会终止当前程序的运行，并打印异常堆栈信息。
2 异常的分类以及继承关系在java中，异常情况分为两在类：exception（异常）类和error （错误）类[2]。
1）错误（error）：jvm系统内部错误或资源耗尽等严重情况属于jvm需要负担的责任。
2）异常（exception）：其它因编程错误或偶然的外在因素导致的一般性问题。
这类异常得到恰当的处理时，程序有机会恢复至正常运行状况。
从编程角度也可以把throwable分为两个分支：1）不受检查（unchecked）异常，包括runtimeexcepton及其子类和error：编译器不要求强制处理的异常。
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. 异常并不能解决所有问题。
异常处理总结
异常处理总结异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C开始，你也许已经知道如何用if...else...来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！Java语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java语言设计者的高明之处，也是Java语言中的一个难点，下面对Java异常知识的一个总结。
一、Java异常的基础知识异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
比如说，你的代码少了一个分号，那么运行出来结果是提示是错误ng.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出ng.ArithmeticException的异常。
有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。
天有不测风云，人有旦夕祸福，Java的程序代码也如此。
在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。
Java中的异常用对象来表示。
Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。
异常类从哪里来？有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。
Exception 类及其子类是Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
异常的对象从哪里来呢？有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。
Java异常处理机制探讨
Java异常处理机制探讨【摘要】异常处理是Java运行机制的特征之一，它是Java语言健壮性的一个重要体现。
本文介绍了异常的分类、异常的处理和异常的捕获策略。
【关键词】Java；异常；异常处理0 引言异常是程序在运行过程中发生的突发事件，比如除0溢出、数组越界、数字格式化等，这些事件阻止程序的正常运行，为了加强程序的健壮性，程序设计时，就必须要考虑到有可能发生的异常事件并做出相应的处理。
1 异常处理的概念C语言中，通过使用if语句来判定是否出现了异常，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的异常事件并进行处理。
Java是面向对象的程序设计语言，通过异常对象调用方法来处理异常。
异常处理对象是Java程序在运行时异常而自动产生的对象，发生不同的异常会产生不同的异常对象，这个对象会由JVM控制去执行相应的异常处理代码。
通常把生成异常对象并把它提交给JVM的过程称为抛出（throw）一个异常。
JVM在方法的调用栈中查找，从生成异常的方法开始进行回朔，直到找到包含相应异常处理的方法为止，这一个过程称为捕获（catch）一个异常。
2 异常的分类异常是程序中的一些错误，但并不是所有的错误都是异常，并且有些异常需要做处理，有些则不需要捕获处理。
Java异常类层次结构，如图1所示。
图1 异常类层次结构Throwable类是所有异常和错误的超类，有两个子类Error和Exception，分别表示错误和异常。
其中异常类Exception又分为运行时异常（RuntimeException）和非运行时异常，这两种异常有很大的区别，也称之为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。
1）Error和ExceptionError是程序无法处理的错误，比如VirtuaMachineError、ThreadDeath等。
这些错误发生时，Java虚拟机（JVM）一般会选择线程终止。
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程序错误类型及异常处理⼀、程序的错误类型在程序设计中，⽆论规模是⼤是⼩，错误总是难免的。
程序的设计很少有能够⼀次完成，没有错误的（不是指HelloWorld这样的程序，⽽是要实现⼀定的功能，具备⼀定实⽤价值的程序），在编程的过程中由于种种原因，总会出现这样或那样的错误，这些程序的错误就是我们常说的“Bug”，⽽检测并修正这些错误的⽅法就是“Debug”（调试）。
基本上所有的集成开发环境都提供了强⼤的和程序调试功能，在程序进⾏编译，连接，运⾏时，会对程序中错误进⾏诊断。
程序的错误可以抽象分为三类：语法错误、运⾏错误和逻辑错误。
1、语法错误是指由于编程中输⼊不符合语法规则⽽产⽣的。
程序编译就通不过，程序不能运⾏起来。
此类错误最简单，调试起来⽐较容易例如：表达式不完整、缺少必要的标点符号、关键字输⼊错误、数据类型不匹配、循环语句或选择语句的关键字不匹配等。
通常，编译器对程序进⾏编译的过程中，会把检测到的语法错误以提⽰的⽅式列举出来，⼜称为编译错误。
语法错误的调试，则可以由集成开发环境提供的调试功能来实现，在程序进⾏编译时，编译器会对程序中的语法错误进⾏诊断。
编译诊断的语法错误分为3中：致命错误、错误和警告。
（1）致命错误：这个错误⼤多是编译程序内部发⽣的错误，发⽣这类错误时，编译被迫中⽌，只能重新启动编译程序，但是这类错误很少发⽣，为了安全，编译前最好还是先保存程序。
（2）错误：这个错误通常是在编译时，语法不当所引起的。
例如：括号不匹配，变量未声明等。
产⽣这类错误时，编译程序会出现报错提⽰，我们根据提⽰对源程序进⾏修改即可。
这类错误是出现最多的。
（3）警告：是指被编译程序怀疑有错，但是不确定，有时可强⾏通过。
例如：没有加void声明的主函数没有返回值，double数据被转换为float类型等。
这些警告中有些会导致错误，有些可以通过。
常规解决⽅法：此类错误⼀般程序编译系统会⾃动提⽰相应的错误地点和错误原因，⽐如哪⼀⾏代码少了个括号等诸如此类的提⽰，常见的错误，看懂直接改正即可，如果是看不懂原因，可以将错误提⽰信息输⼊搜索引擎查找⼀下，⼀般都能找到具体的解决办法。
第05章 异常处理
3.
类型强制转换异常ClassCastException Object obj = new Object();
String str = (String) obj;
《Java2程序设计实用教程（第2版）》
RuntimeException类(P131)
4.
负数组长度异常NegativeArraySizeException
int a[] = new int [-1]; //产生负数组长度异常 数组下标越界异常ArrayIndexOutOfBoundsException
5.
int a[] = new int[1];
a[1] = 1;
6.
//产生数组下标越界异常
数值格式异常NumberFormatException int j = Integer.parseInt("abc"); //产生数值格式异常
《Java2程序设计实用教程（第2版）》
5.1 Java异常处理基础
2.
Exception类分为：运行时异常和非运行时异常
运行时异常：是指由程序本身错误引起的异常，这类 异常程序设计时大多可以避免；如，除数为0，数组 下标越界。 （RuntimeException）
非运行时异常：是指由程序运行环境错误引起的异常，
能力。
《Java2程序设计实用教程（第2版）》
5.3 抛出异常
生成抛出异常：产生一个异常事件，生成一个异常对象。
Java虚拟机或Java应用程序 throw new Exception();
捕获处理异常：找到可处理此异常对象的方法所在的位 置，执行处理方法对异常对象进行处理。 Java虚拟机或 Java应用程序 try-catch-finally 只能是 Exception类及 其子类的对象
Java异常处理机制及其在项目中的应用
在一个完美的世界中 ，用户输入数据 的格式永 远都
是正确的 ，选择打开的文件也一定是存在 的，并且代码 永远是 不会 出现ｂ ｇ 。然而 ，在现实世界 中却充 满了 ｕ的 各种不 良的数据和有问题 的代码 ，Ｊｖ 程序设计语 言使 ａａ
就用非运行时异 常吧。
二 、异 常 的捕获 和处 理
Ｅ ｃ ｐｉｎ ｘ ｅ ｔ 的层 次结构 。Ｅ ｃ ｐｉｎ Ｌ 为运行 时异 常 ｏ ｘ ｅｔ ３分 ｏ
（ ｕ ｔ Ｅ ｃｐｉｎ和非运行时异常 。由程序错误 导致 Ｒ ｎｉ ｘ ｅｔ ） ｍｅ ｏ
的异 常属 于Ｒ ｎｉ Ｅ ｃｐｉｎ ｕｔ ｍｅ ｘ ｅ ｔ ；曾经能够正确运行 ，而 ｏ 由于某 些情况 （ 例如 ，Ｉ 错 误 ）导致 的异常属 于非运 ／ Ｏ
行时异常 。请切 记 “ 如果出现Ｒ ｎｉ Ｅ ｃｐｉｎ ｕｔ ｍｅ ｘｅ ｔ 异常 ， ｏ
就一定是你的问题 ” ，马上修改你 的程序 。如果客户端
费的时 间很 大 。因此 ，请 只在异常情 况下使 用异常机
制。
可以根据异常采取一些替代行为来恢复系统运行 ，那 么
９ ８
信 息 系统工程 ｌ２ １．１ ０ ０ １１． ２
Ｔ ｏ ｗａ ｌ类有 两个 子 类Ｅ ｒ ｒ ｘ ｅ ｔ ｎ ｈ ｒ ｂｅ ｒｏ 和Ｅ ｃ ｐ ｉ ，分 ｏ
对一个空栈进行退栈操 作 。代码Ａ 使用ｉ 句查看栈 是 鼯
否为空；代码Ｂ 使用异常捕获方式 。 代码Ａ：ｉ ！ｅ ｔ（） ． ｐ ） ｆ ｓ ｍｐ ）ｓ ｏ （； （． ｙ ｐ
别 表 示 错 误 和 异 常 。 进 行 程 序 设 计 时 ，需 要 关 注
ｊ ａｃ ｔ ｃ Ｅｘ ｅ ｉ ｎｅ ｛ ｃ ｐｔ ｏ
Java异常处理
异常的分类
异常的分类
Throwable
用户自己产生的异常 .
要处理 Error 不做处理 由用户捕获或 声明并处理
Exception RuntimeException
缺省的异常 处理程序
例外的分类
一个例外是由一个对象来代表的,所有的例外都 直接或间接地继承自Throwable类. 在Java类库的每个类包中都定义了例外类,这些 例外类分成两大类:Error类及Exception类,后者是 Java程序中需要大量处理的. 除了Java类库所定义的例外类之外,用户也可以 通过继承已有的例外类来定义自己的例外类,并在 程序中使用(利用throw产生,throws声明抛出, catch捕捉并处理).
捕获异常
捕获并处理异常 try { //接受监视的程序块,在此区域内发生 //的异常,由catch中指定的程序处理; } // 不能有其它语句分隔 catch(要处理的异常种类和标识符) { //处理异常; }catch(要处理的异常种类和标识符) { //处理异常; }
捕获例外
try语句 捕获例外的第一步就是用try {…}语句指定了一 段代码,该段代码就是一次捕获并处理例外的范围. 在执行过程中,该段代码可能会产生并抛弃一个或 多个例外,因此,它后面的catch语句进行捕获时也 要做相应的处理. 如果没有例外产生,所有的catch代码段都被略过 不执行.
—— catch语句 catch语句
尽量避免用一般类型作为catch中指定要捕获的类型.
一般应该按照try代码块中例外可能产生的顺序及其真正类型 进行捕获和处理,
在例外处理中无法访问try代码段中声明的变量
因为此时try代码段已经退出了,例外处理所需要的任何信息 一般都应该通过例外对象来传递
java基础篇之异常 D
异常异常的定义在《java编程思想》中这样定义异常：阻止当前方法或作用域继续执行的问题。
虽然java中有异常处理机制，但是要明确一点，决不应该用"正常"的态度来看待异常。
绝对一点说异常就是某种意义上的错误，就是问题，它可能会导致程序失败。
之所以java要提出异常处理机制，就是要告诉开发人员，你的程序出现了不正常的情况，请注意。
记得当初学习java的时候，异常总是搞不太清楚，不知道这个异常是什么意思，为什么会有这个机制？但是随着知识的积累逐渐也对异常有一点感觉了。
调用抛出异常的方法，必须处理异常，有两种方式：1、使用try catch finally 捕获。
2、直接再抛出异常。
注：处理异常的方式依赖于具体业务逻辑，可灵活处理。
如果代码有异常发生，异常以后的代码将不再执行。
举一个例子来说明一下异常的用途。
public class Calculator {public int devide(int num1, int num2) {// 判断除数是否为0if (num2 == 0) {throw new IllegalArgumentException("除数不能为零");}return num1 / num2;}}看一下这个类中关于除运算的方法，如果你是新手你可能会直接返回计算结果，根本不去考虑什么参数是否正确，是否合法（当然可以原谅，谁都是这样过来的）。
但是我们应尽可能的考虑周全，把可能导致程序失败的"苗头"扼杀在摇篮中，所以进行参数的合法性检查就很有必要了。
其中执行参数检查抛出来的那个参数非法异常，这就属于这个方法的不正常情况。
正常情况下我们会正确的使用计算器，但是不排除粗心大意把除数赋值为0。
如果你之前没有考虑到这种情况，并且恰巧用户数学基础不好，那么你完了。
但是如果你之前考虑到了这种情况，那么很显然错误已在你的掌控之中。
异常案例：public class User {int id;String email;String pwd;public User() {}public User(int id, String email, String pwd) {super();this.id = id;this.email = email;this.pwd = pwd;}@Overridepublic String toString() {return id + "," + email;}@Overridepublic boolean equals(Object obj) {if (obj == null) {return false;}if (this == obj) {return true;}if (obj instanceof User) {User o = (User) obj;return id == o.id;}return false;}@Overridepublic int hashCode() {return id;}}-----------------------------------------------import java.util.HashMap;import java.util.Map;/*** 该类提供用户管理功能：注册和登录*/public class UserManager {// 存储user对象的集合，key是email，value是用户private Map<String, User> users = new HashMap<String, User>();private int id = 1;public User reg(String email, String pwd) throws UserExsitsException {if (users.containsKey(email)) {throw new UserExsitsException("该邮箱" + email + "已存在!");}User newuser = new User(id++, email, pwd);users.put(email, newuser);return newuser;}public User login(String email, String pwd) throws EmailOrPwdException {if (!users.containsKey(email)) {throw new EmailOrPwdException("无此用户！");}User u = users.get(email);if (!u.pwd.equals(pwd)) {throw new EmailOrPwdException("密码错误！");}return u;}}/*** 该类表示用户已注册过异常，一定继承于excetpion类* 用于表示注册时可能已经注册过异常*/class UserExsitsException extends Exception {public UserExsitsException(String message) {super(message);}}/*** 该类表示用户名或密码错误异常，一定继承于exception类* 用于表示输入的用户名或密码错误异常*/class EmailOrPwdException extends Exception {public EmailOrPwdException(String message) {super(message);}}----------------------------------------------------public class ExceptionDemo {public static void main(String[] args) throws Exception { UserManager mgr = new UserManager();User u = mgr.reg("java_manual@", "123abc");System.out.println("注册成功！");// 测试1，重复注册，出现异常u = mgr.reg("java_manual@", "123abc");// 测试2，登录密码错误，出现异常，密码不对u = mgr.login("java_manual@", "abc");// 测试3，登陆成功！User someone = mgr.login("java_manual@", "123abc");System.out.println(someone);}}注：代码调用抛出异常的方法，必须处理异常，有两种方式：1、使用try catch finally 捕获。
异常处理总结
异常处理1、为什么要引入异常处理机制我们的程序在编译或运行时可能会出问题，当出现问题的时候程序就死掉了，这样的程序健壮性不好。
因此在JAVA中我们引入了异常处理机制，既保证能及时发现问题并加以纠正，又能保证程序不死掉。
JAVA中保证程序健壮性的方式有三种：垃圾回收机制（保证不会发生内存泄露）弃用指针（保证不能直接对底层进行操作）异常处理机制（保证程序不会因发生异常而死掉）2、什么是异常处理机制2.1、异常的定义程序问题的分类：错误(Error)：严重的错误，无法通过修改代码来处理。
如JVM运行失败、线程池出错导致JVM无法正确运行。
异常(Exception)：异常表示程序执行过程中出现的不正常的现象，可以通过修改代码来进行弥补。
⏹ 异常的分类：◆ 运行时异常(unchecked)：运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
◆ 编译时异常(checked)：编译时异常是RuntimeException以外的异常，类型上都属于Exception类及其子类。
从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。
如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
⏹ 异常处理的顺序：◆ 引发异常（检测异常情况并生成异常的过程叫引发异常）◆ 捕获异常（当异常被引发时，可被处理程序捕获）◆ 处理异常（上面的两个过程总称为处理异常）2.2、异常的捕获和处理机制Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws 一个异常处理块的通常语法形式：Try{//可能引发异常的语句}Catch(ExceptionType1 ex){//获得此类异常信息并处理异常的代码}Catch(ExceptionType2 ex){//获得此类异常信息并处理异常的代码}（注意：Catch块的放置顺序，捕获子类异常放前面，捕获父类异常放后面）…………Finally{//一般为释放资源的语句}⏹ 以上语法有三个代码块：try语句块，表示要尝试运行代码，try语句块中代码受异常监控，其中代码发生异常时，会抛出异常对象。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
任何计算机语言的程序都难免有漏洞，捕 获错误最理想的地方是在程序的编译期间， 然而，在实际的程序设计中，并非所有错误 都能在编译期间侦测到。
例如：类文件丢失、想打开的文件不存在、 网络连接中断、操作数超出预定范围等。
这些在程序执行中，中断正常程序流程 的事件称为错误或异常。
异常及其分类
错误和异常
Error
Object Throwable
Exception
AWTExceptioimeException
异常及其分类
常用异常类
运行时异常，程序应尽量避免而不捕获 ArithmeticException：一个不寻常算术运算产 生的异常。 ArrayIndexOutOfBoundsException：数组索 引超出范围所产生的异常。 ClassCastExcption：类对象强迫转换不当所产 生的异常。 NullPointerException：对象引用参考值为null 所产生的异常。
Part Two
第二讲 异常及其分类
异常及其分类
软件的容错性
软件系统不仅自身不能有错误，还要具备较强的抗干 扰能力。即使在用户操作时出现错误，或遇到其他意 外的干扰时，软件系统不但不能崩溃，而且必须尽最 大努力排除错误和干扰继续运行。只有这样的软件系 统才会具有旺盛的生命力和广泛的应用空间。
异常及其分类
异常及其分类
常用异常类 其它异常，必须捕获 ClassNotFoundException：找不到类或接口 所产生的异常。 InterruptedException：目前线程等待执行， 另一线程中断目前线程所产生的异常。 IOException：输入输出访问异常。
异常分类
运行时异常，程序应尽量避免而不捕获 对于程序能够预见的异常，如除数为0、数组 下标越界等，程序应该考虑周到、事先处理，尽 量避免发生异常。 其它异常，必须捕获 由特殊环境错误造成的异常，如文件没找到、 网络通信失败等， 必须进行捕获和处理，从而保 证程序正常运行。
异常及其分类
异常类的层次结构
错误指程序运行时遇到的硬件或操作系统的错 误，如内存溢出、虚拟机错误等。 错误对于程序而 言是致命性的，错误将导致程序无法运行，而且程序 本身不能处理错误。
异常指在硬件和操作系统正常时，程序遇到的 运行错误，如进行除法运算时除数为0，或打开一个 文件时发现文件不存在，或网络连接中断等。
异常及其分类