本文目录
- 如何简述java中的异常处理机制，有什么实际例子
- 有哪位高手能告诉我异常处理机制指的是什么意思
- Java中异常处理机制有哪些
- c++中异常的处理机制是什么
- java异常处理的机制有哪几种
- 生产异常的处理方法有哪些
- 在java中，异常处理的机制有哪几种，分别是什么
- 简述Java中异常处理的机制
如何简述java中的异常处理机制，有什么实际例子
java 中的异常处理机制有两种：第一种就是直接抛出去，抛到了JVM中。这个异常直接被JVM杀死。第二种就是捕获。这两种处理的方式都很常用。
举个例子：
第一种抛出异常。
将异常抛出去那是因为在应用当中 作用不是很大。
第二种就是捕获：
这种方式 是因为出现的异常有用，打个比方：进行数据库的连接，但是突然网络中断了，数据库连接失败，我们捕获这个异常，就可以方便开发人员执行调试。
有哪位高手能告诉我异常处理机制指的是什么意思
异常处理功能提供了处理程序运行时出现的任何意外或异常情况的方法。异常处理使用 try、catch 和 finally 关键字来尝试可能未成功的操作，处理失败，以及在事后清理资源。
异常可以由公共语言运行库 (CLR)、第三方库或使用 throw 关键字的应用程序代码生成。
异常具有以下特点：
1.在应用程序遇到异常情况（如被零除情况或内存不足警告）时，就会产生异常。
2.发生异常时，控制流立即跳转到关联的异常处理程序（如果存在）。
3.如果给定异常没有异常处理程序，则程序将停止执行，并显示一条错误信息。
4.可能导致异常的操作通过 try 关键字来执行。
5.异常处理程序是在异常发生时执行的代码块。在 C# 中，catch 关键字用于定义异常处理程序。
6.程序可以使用 throw 关键字显式地引发异常。
7.异常对象包含有关错误的详细信息，其中包括调用堆栈的状态以及有关错误的文本说明。
8.即使引发了异常，finally 块中的代码也会执行，从而使程序可以释放资源。
异常处理理论上有两种基本模型.
一种称为“终止模型“(它是Java与C++所支持的模型).在这种模型中,将假设错误非常关键,将以致于程序无法返回到异常发生的地方继续执行.一旦异常被抛出,就表明错误已无法挽回,也不能回来继续执行.
另一种称为“恢复模型“.意思是异常处理程序的工作是修正错误,然后重新尝试调动出问题的方法,并认为的二次能成功.
对于恢复模型,通常希望异常被处理之后能继续执行程序.在这种情况下,抛出异常更像是对方法的调用--可以在Java里用这种方法进行配置,以得到类似恢复的行为.(也就是说,不是抛出异常,而是调用方法修正错误.)或者,把try块放在while循环里,这样就可以不断的进入try块,直到得到满意的结果.
虽然恢复模型开始显得很吸引人,并且人们使用的操作系统也支持恢复模型的异常处理,但程序员们最终还是转向了使用类似“终止模型“的代码.因为:处理程序必须关注异常抛出的地点,这势必要包含依赖于抛出位置的非通用性代码.这增加了代码编写和维护的困难,对于异常可能会从许多地方抛出的大型程序来说,更是如此.
Java中异常处理机制有哪些
1.try和catch语句
●将要处理的代码放入try块中，然后创建相应的catch块的列表。如果生成都异常与catch中提到的相匹配，那么catch条件中的块语句就被执行。try块后可能有许多catch块，每个都处理不同的异常。每个catch中的参数都是Exception的子类。
2.finally语句
●finally语句定义一个总是执行的代码，而不考虑异常是否被捕获。
3.throw引起一个异常
●调用申明抛出异常
public class Test{
static void MethodA() throws ArrayIndexOutOfBoundsException{
int a = {1, 2, 3};
for (int i = 0; i 《 4; i++) {
System.out.println(a[i]);
}
}
public static void main(String args){
try {
MethodA();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e);
}
}
}
●throw语句强制抛出异常
public class Test{
public static void main(String args){
try {
throw new ArrayIndexOutOfBoundsException();
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(e);
}
}
}
c++中异常的处理机制是什么
异常处理允许用户以一种有序的方式管理运行是出现的错误。使用C＋＋的异常处理，用户程序在错误发生时可自动调用一个错误处理程序。异常处理最主要的优点是自动转向错误处理代码，而以前在大程序中这些代码是由“手工”编制的。
注：异常处理不属于C＋＋原始规范的范畴。它是在1983年间发展起来的。异常处理由建
议的ANSI C＋＋标准定义，被现存大多数C＋＋编译程序所支持。
C＋＋异常处理建立在三个关键字基础之上：try、catch和throw。
通常，监测异常情况的程序语句包含在try中。如果try块中发生了异常（也就是错误），则用throw处理。异常由catch捕获，并得到处理。
下面详细讨论这些论点。
抛出异常的语句必须在try块中执行（在try块中调用的函数也可能抛出异常）。任何异常必须由紧跟在抛出异常的try语句之后的catch语句捕获。
try和catch的一般形式如下：
try{
// try block
}
catch（type1 arg）{
//catch block
｝
catch （type2 arg）{
// catch block
}
catch（type3 arg）｛
// catch block
｝
catch(typeN arg) {
// catch block
｝
try块必须包括用户程序中监测错误的部分。它们可以短至函数中的几条语句，也可以是象try块（有效地监测整个程序）中main（）函数的代码那样完全包装。
异常发生时，由相应的catch语句去捕获并处理此异常。与一个try相关的catch语句可能不止一条。至于使用哪条catch语句，则由异常的类型决定。也就是说，如果由catch语句说明的数据类型与异常情况匹配，则此catch语句（其它catch语句跳过）执行。当捕获一个异常时，arg将接受它的值。可以捕获任何类型的数据，包括用户创建的类。如果try块中无异常（错误）发生则不执行任何catch语句。
throw语句的一般形式如下：
throw exception；
throw必须在try块中或在try块中任何直接或间接调用的函数中执行。exception是被抛出的一个值。
如果对于抛出的异常没有合适的catch语句，则会发生程序异常终止。如果用户的编译程序符合建议的ANSI C＋＋标准，那么抛出一个未被处理的异常会引起调用terminate（）函数。缺省时，terminate（）调用abort（）终止用户程序，但如果用户愿意，则可以定义自己的终止处理程序。
java异常处理的机制有哪几种
Java语言提供两种异常处理机制：捕获异常和声明抛弃异常；
1）捕获异常：在Java程序运行过程中系统得到一个异常对象是，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型异常的方法后，运行时系统把当前异常交给这个方法处理；如果找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。捕获异常是通过try-catch-finally语句实现的。语法为：
try{
...
}catch(ExceptionName1 e){
...
}catch(ExceptionName2 e){
...
}
...
}finally{
...
}
2)声明抛弃异常：当Java程序运行时系统得到一个异常对象时，如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，声明抛弃异常。声明抛弃异常是在一个方法声明中的throws子句中指明的。如：
public int read() throws IOException{
...
}
其中throws IOException就是声明抛弃异常，throws后可以跟多个异常类型。
生产异常的处理方法有哪些
在生产过程中，生产日计划不能够执行到位，很多时候并不是计划本身有问题，而是在执行计划的过程中，产品在生产的过程中会出现各类异常。生产异常主要有来料品质的异常、人员的异常、制程品质的异常等等。
在生产过程中因为有这些异常，就会出现瓶颈，在中小企业的生产过程中，这些异常和瓶颈是时时会发生的，要想让生产计划能够准时完成，就必须要有一套快速应对、快速处理异常的机制。
任何异常都是逐渐或临时偏离标准发生的，小的异常处理不及时或不当，就可能因发生多米诺骨牌效应而按照几何级数演变成大的异常。因此，对生产异常的分析与防范、及时响应、规范处理，是每个企业都迫切需要关注的焦点问题，同时这也是中小企业工厂生产管理的重点。
人为因素导致的异常处理
进行岗位操作培训是预防人为因素导致生产异常的最基本解决方法之一。特别是对于新员工，培训不合格者严禁上岗。要求员工熟练掌握并严格遵守本岗位的作业要领或生产作业操作规程，加强生产过程控制。
建立有效沟通机制是快速找出生产异常发生原因的关键措施之一。不论是否发生生产异常现象，企业管理者都应树立“以人为本”的态度，建立一个长效沟通机制。有则修正，无则加勉，积极应对。
对操作人员实行权限分级与岗位分级管理，不同权限的人员操作不同的内容，不同岗位的人员操作不同岗位内容，减少工作任务的交叉和重叠，实施“定岗、定编、定人、定责”规范人员管理，减少因人的因素导致的异常问题。
生产原材料异常处理
加强原材料的进厂检验和使用前核对工作，确保每道工序使用物料的正确性。生产计划下达后，相关人员需要立即确认物料状况，查验物料有无短缺，即物料库存数量是否满足生产，进行动态的跟踪和反馈，避免异常的发生。
生产工艺方法异常处理
避免操作方法异常的发生，最首要的任务便是标准作业指导书的制定及实施，不断优化生产工艺技术参数，保证产品加工质量。保持工装和夹具的精度，并定期检测和维护。加强关键工序和特殊工序的过程控制。
严肃工艺纪律，检查和监督员工是否真正贯彻执行生产操作规程，杜绝私自更改工艺和图纸。当工艺异常发生后，迅速通知品管、生技或研发等部门，立即采取应对措施。
产品品质异常处理
对生产难度大、不良品较多以及特殊要求的产品，应在生产前做好重点规划，异常发生时，迅速用警示灯、电话或其他有效方式迅速通知品管部及相关部门，减少和杜绝异常的发生。加强产品首检、自检、抽检和互检，根据产品的质量要求及复杂程度适当增加专检频次。加强质检人员的质量否决权，管理人员随时巡检，产品销售出库时严格进行检验，杜绝不合格品入库、出厂。
生产部协助品管、责任部门一起研究对策，配合临时对策的实施，以确保生产任务的完成。做好后续的记录，运用QC工具（如柏拉图、因果分析图、直方图等）进行统计分析，积极寻找根治异常的方法。
生产计划的异常处理
根据市场发展的趋势，在制定生产计划时要具有一定弹性，以便出现异常时可以根据实际情况迅速合理的调整计划。
安排因计划调整而遗留的产品、半成品、原材料的盘点、入库、清退等处理工作，安排人员以最快速度做好计划更换的物料、设备等准备工作。
质量管理系统辅助
该系统实现质量信息数据化、实时化，采集方式多样化，遵循QC七大手法进行品质异常处理，自动生成MRB/8D报告，多端兼容，实现质量跟踪、缺陷预测、预警与防伪溯源等全流程大数据服务。
在java中，异常处理的机制有哪几种，分别是什么
1 引子
try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
package myExample.testException;
public class TestException {
public TestException() {
}
boolean testEx() throws Exception{
boolean ret = true;
try{
ret = testEx1();
}catch (Exception e){
System.out.println(“testEx, catch exception“);
ret = false;
throw e;
}finally{
System.out.println(“testEx, finally; return value=“+ret);
return ret;
}
}
boolean testEx1() throws Exception{
boolean ret = true;
try{
ret = testEx2();
if (!ret){
return false;
}
System.out.println(“testEx1, at the end of try“);
return ret;
}catch (Exception e){
System.out.println(“testEx1, catch exception“);
ret = false;
throw e;
}
finally{
System.out.println(“testEx1, finally; return value=“+ret);
return ret;
}
}
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i》=-2;i--){
c=b/i;
System.out.println(“i=“+i);
}
return true;
}catch (Exception e){
System.out.println(“testEx2, catch exception“);
ret = false;
throw e;
}
finally{
System.out.println(“testEx2, finally; return value=“+ret);
return ret;
}
}
public static void main(String args) {
TestException testException1 = new TestException();
try{
testException1.testEx();
}catch(Exception e){
e.printStackTrace();
}
}
}
你的答案是什么？是下面的答案吗？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所说，那么你错啦。^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。
现在公布正确答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
2 基础知识
2.1 相关概念
例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。全程变量ErroNo常常用来反映一个异常事件的类型。但是，这种错误处理机制会导致不少问题。
Java通过面向对象的方法来处理例外。在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。
2.2 Throwable类及其子类
用面向对象的方法处理例外，就必须建立类的层次。类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。图1表示了例外处理的类层次。
从图中可以看出，类Throwable有两个直接子类：Error和Exception。Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。它有各种不同的子类分别对应于不同类型的例外。其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。
图1 例外处理的类层次
2.3 异常处理关键字
Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的：
Throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
Try： Opening exception-handling statement.
Catch： Captures the exception.
Finally： Runs its code before terminating the program.
2.3.1 try语句
try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
2.3.2 catch语句
catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。
2.3.3 finally语句
try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。
2.3.4 throws语句
throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序的正常部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。
2.3.5 throw语句
throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
3 关键字及其中语句流程详解
3.1 try的嵌套
你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。下面是一个try语句嵌套的例子。
class MultiNest {
static void procedure() {
try {
int a = 0;
int b = 42/a;
} catch(java.lang.ArithmeticException e) {
System.out.println(“in procedure, catch ArithmeticException: “ + e);
}
}
public static void main(String args) {
try {
procedure();
} catch(java.lang. Exception e) {
System.out.println(“in main, catch Exception: “ + e);
}
}
}
这个例子执行的结果为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
成员函数procedure里有自己的try/catch控制，所以main不用去处理 ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
in main, catch Exception: java.lang.ArithmeticException: / by zero
3.2 try-catch程序块的执行流程以及执行结果
相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1． 如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。
2． 如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
² 如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
² 如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。
3． 如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
3.3 try-catch-finally程序块的执行流程以及执行结果
try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况：
1． 如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：
² 如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
² 如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
2． 如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：
² 如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：
² 如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：
² 如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
² 如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”
² 如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：
² 如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。
这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。）
² 如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况：
² 如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3． 如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况：
² 如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
3.4 try-catch-finally程序块中的return
从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。
例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。
3.5 如何抛出异常
如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：
第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch。比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。
boolean testEx2() throws Exception{
boolean ret = true;
int b=12;
int c;
for (int i=2;i》=-2;i--){
c=b/i;
System.out.println(“i=“+i);
}
return true;
}
第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i》=-2;i--){
c=b/i;
System.out.println(“i=“+i);
}
return true;
}catch (Exception e){
System.out.println(“testEx2, catch exception“);
Throw e;
}
}
第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i》=-2;i--){
c=b/i;
System.out.println(“i=“+i);
throw new Exception(“aaa“);
}
return true;
}catch (java.lang.ArithmeticException e){
System.out.println(“testEx2, catch exception“);
ret = false;
throw new Exception(“aaa“);
}finally{
System.out.println(“testEx2, finally; return value=“+ret);
}
}
4 关于abrupt completion
前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。
4.1 Normal and Abrupt Completion of Evaluation
每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。
与表达式、操作符相关的运行期异常有：
² A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
² An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
² A field access throws a NullPointerException if the value of the object reference expression is null.
² A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
² An array access throws a NullPointerException if the value of the array reference expression is null.
² An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
² A cast throws a ClassCastException if a cast is found to be impermissible at run time.
² An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
² An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况：
² break, continue, and return 语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。
² 某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。
如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly.
导致abrupt completion的几种原因：
² A break with no label
² A break with a given label
² A continue with no label
² A continue with a given label
² A return with no value
² A return with a given value A
² throw with a given value, including exceptions thrown by the Java virtual machine
5 关于我们的编程的一点建议
弄清楚try-catch-finally的执行情况后我们才能正确使用它。
如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。（我们需要记住：不仅throw语句是abrupt completion 的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。）
简述Java中异常处理的机制
有两中方式:1.捕获异常,自己处理.
2.throw出去,让别人处理.
举个例子:
public class A{
try{
可能发生异常的语句...
}catch(Exception e){
e.getMessage();//自己处理
}
}
public class A throws Exception{
可能发生异常的语句...
}//throw出去,让别人处理
注意这里用的是throws
如果在方法里面则用throw
举例:
public class A{
try{
可能放生异常的语句...
}catch(Exception e){
e.getMessage();//自己处理
throw new Exception (““);
}
}
