try{ try{}catch{}finally{}}finally{}里面的try报了异常会怎么执行_百度知道1.异常的处理方式有两种分别为：try{}catch{}finally{}和throws下面简单说一下这两者的区别和联系。
2.出现异常之后如果没有进行捕获处理系统就会直接将这个异常栈的跟踪信息直接打印出来之后就结束这个程序的执行。
下面我们看一下异常处理：
public class Test{
public static void main(String[] args){
Test2 test2 = new Test2();
System.out.println("invoke the method begin!");
test2.method();
System.out.println("invoke the method end!");
}catch(Exception e){
System.out.println("catch Exception!");
class Test2{
public void method() throws Exception{
System.out.println("method begin!");
int a = 10;
int b = 0;
int c = a/b;
System.out.println("method end!");
很明显，答案出来了：
invoke the method begin!
method begin!
catch Exception!
&对于try{}catch{}finally{}而言，用户可能确定知道代码会出现相关的异常，把有可能出现问题的地方放到try中去执行，如果一旦出现异常，立刻终止当前代码的继续
&执行，转而去执行catch{}里面的内容。对于这类异常用户已经处理了，不会在向上抛出。
&对于throws而言，一般使用在方法名的后面，使用throws关键字的时候，一般是开发者不确定出现什么异常或者出现异常的情况可能有多种。这时开发者在方法后面加　　&throws关键字抛出相关的异常。对于调用该方法的其它开发者者必须捕获这个异常或者继续throws这个异常，把这个异常传递下去，交给其对应的父类去处理。
&需要注意throw关键字和throws关键字是有区别的。throw一般用于方法中，抛出用户自定义的异常如 throw new MyException("用户自定义异常")。
&而throws是用在方法名的后面，通知使用该方法的人，当前方法有可能抛出异常。
&如果简单的理解可以这样看：对于throws可以理解为抛出，抛出给别人，自己不处理。而try{}catch{}finally{}则可以理解为截断，开发者自己处理这个异常。
3.异常处理的执行顺序（针对try{}catch{}finally{}而言）
&&&& 对于try{}catch{}finally{}而言，，它们的执行顺序很简单，如果在try{}中捕获相应的异常，中断当前代码的执行，转而去执行catch{}中的内容，最后去执行
&&& finally{}中方法，一般来说finally中的方法都是会被执行的，其中finally中很大程度上用于资源的释放。
&&& 下面讲解一些我们java程序员需要注意的地方。
&&&&&&&&& a、finally中的代码总是会执行吗？
&&&&&&&&&&&& 答：no，如果一个方法内在执行try{}语句之前就已经return了，那么finally语句指定不会执行了。因为它根本没有进入try语句中
&&&&&&&&&&&&&&&&&&&&&&& 如果在一个try语句中调用System.exit(0);方法，那么就会退出当前java虚拟机，那么finally也就没有执行的机会了。
&&&&&&&&& b、finally在return之前执行还是在return之后执行？
&&&&&&&&&&& 答：很多人可能会说在return执行之前执行。我的答案是在return中间执行，是不是很特别，请按下面的例子:
package com.yonyou.
class Test{
public static void main(String[] args) {
System.out.println(method());
public static int method(){
}catch(Exception e)
请问输出的结果是多少呢？
&&& 正确答案是：1
&& 下面我来讲解一下这个程序的执行过程，
&&& 首先程序在执行到try{}语句中的return方法后，就会先返回相应的值，并把相应的值存储在一个临时栈中去保存这个结果。这时临时栈中存储的值为1。
&&& 但是程序不会立刻返回，转而回去执行finally中的方法，++x，在finally执行完后，方法全部执行完，这时会再次调用return方法，注意这时
&& 不在是返回值，而是告诉主调程序，被调程序已经执行完了，你可以接着去执行你主程序的其它方法了。但是请注意，此时返回的值还是原来保存在临时
&& 栈中的值1。
&为了更好的理解这个问题，我们看下面的程序：
package com.yonyou.
class Test{
public static void main(String[] args) {
System.out.println(method());
public static int method(){
}catch(Exception e)
这时的正确答案又是多少呢？
&&&& 没错是2，这里仅仅需要注意的是在try{}语句中执行到return 1 会在临时栈中存储值为1的变量。接着回去执行finally里面的内容，这时执行finally中的return 2;方法，这时
&&& 临时栈中的值就是变为 2，会覆盖原来临时栈中的值1.所以它的返回值为2。
&&&& c、finally方法是必须的吗？
&&&&&&&& 不是，开发者可以根据自身的情况去决定是否使用finally关键字。
总结：在try中没有异常的情况下try、catch、finally的执行顺序 try --- finally如果try中有异常，执行顺序是try --- catch --- finally如果try中没有异常并且try中有return这时候正常执行顺序是try ---- finally --- return如果try中有异常并且try中有return这时候正常执行顺序是try ---- catch& ---- finally --- return如果在try和catch中没有执行System.exit();那么 finally 永远执行！
阅读(...) 评论()看了一位博友的一片文章，讲解的是关于java中关于try、catch、finally中一些问题
下面看一个例子（例1），来讲解java里面中try、catch、finally的处理流程
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
} catch (Exception e) {
// result = "catch";
t = "catch";
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
　　首先程序执行try语句块，把变量t赋值为try，由于没有发现异常，接下来执行finally语句块，把变量t赋值为finally，然后return t，则t的值是finally，最后t的值就是finally，程序结果应该显示finally，但是实际结果为try。为什么会这样，我们不妨先看看这段代码编译出来的class对应的字节码，看虚拟机内部是如何执行的。
我们用javap -verbose TryCatchFinally 来显示目标文件(.class文件)字节码信息
系统运行环境：mac os lion系统 64bit
jdk信息：Java(TM) SE Runtime Environment (build 1.6.0_29-b11-402-11M3527)&Java HotSpot(TM) 64-Bit Server VM (build 20.4-b02-402, mixed mode)
编译出来的字节码部分信息，我们只看test方法，其他的先忽略掉
public static final java.lang.String test();
Stack=1, Locals=4, Args_size=0
#16; //String
#18; //String try
#20; //String finally
#22; //String catch
#20; //String finally
#20; //String finally
Exception table:
target type
Class java/lang/Exception
LineNumberTable:
line 15: 8
line 9: 11
line 10: 13
line 12: 14
line 13: 17
line 15: 19
line 13: 22
line 14: 24
line 15: 25
line 16: 28
LocalVariableTable:
Ljava/lang/String;
Ljava/lang/Exception;
StackMapTable: number_of_entries = 2
frame_type = 255 /* full_frame */
offset_delta = 13
locals = [ class java/lang/String ]
stack = [ class java/lang/Exception ]
frame_type = 74 /* same_locals_1_stack_item */
stack = [ class java/lang/Throwable ]
首先看LocalVariableTable信息，这里面定义了两个变量 一个是t String类型,一个是e Exception 类型
接下来看Code部分
第[0-2]行，给第0个变量赋值&&，也就是String t=""；
第[3-6]行，也就是执行try语句块 赋值语句 ，也就是 t = "try";
第7行，重点是第7行，把第s对应的值"try"付给第三个变量，但是这里面第三个变量并没有定义,这个比较奇怪
第[8-10] 行，对第0个变量进行赋值操作，也就是t="finally"
第[11-12]行，把第三个变量对应的值返回
通过字节码，我们发现，在try语句的return块中，return 返回的引用变量（t 是引用类型）并不是try语句外定义的引用变量t，而是系统重新定义了一个局部引用t&，这个引用指向了引用t对应的值，也就是try ，即使在finally语句中把引用t指向了值finally，因为return的返回引用已经不是t ，所以引用t的对应的值和try语句中的返回值无关了。
下面在看一个例子：（例2）
1 public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
} catch (Exception e) {
// result = "catch";
t = "catch";
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这里稍微修改了 第一段代码，只是在finally语句块里面加入了 一个 return t 的表达式。
按照第一段代码的解释，先进行try{}语句，然后在return之前把当前的t的值try保存到一个变量t'，然后执行finally语句块，修改了变量t的值，在返回变量t。
这里面有两个return语句，但是程序到底返回的是try 还是 finally。接下来我们还是看字节码信息
public static final java.lang.String test();
Stack=1, Locals=2, Args_size=0
#16; //String
#18; //String try
#20; //String catch
#22; //String finally
Exception table:
target type
Class java/lang/Exception
LineNumberTable:
line 10: 9
line 12: 10
line 13: 13
line 14: 16
line 15: 17
line 16: 20
LocalVariableTable:
Ljava/lang/String;
Ljava/lang/Exception;
StackMapTable: number_of_entries = 3
frame_type = 255 /* full_frame */
offset_delta = 9
locals = [ class java/lang/String ]
stack = [ class java/lang/Exception ]
frame_type = 70 /* same_locals_1_stack_item */
stack = [ class java/lang/Throwable ]
frame_type = 0 /* same */
这段代码翻译出来的字节码和第一段代码完全不同，还是继续看code属性
第[0-2]行、[3-5]行第一段代码逻辑类似，就是初始化t，把try中的t进行赋值try
第6行，这里面跳转到第17行，[17-19]就是执行finally里面的赋值语句，把变量t赋值为finally，然后返回t对应的值
我们发现try语句中的return语句给忽略。可能jvm认为一个方法里面有两个return语句并没有太大的意义，所以try中的return语句给忽略了，直接起作用的是finally中的return语句，所以这次返回的是finally。
接下来在看看复杂一点的例子：（例3）
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (Exception e) {
t = "catch";
} finally {
t = "finally";
// System.out.println(t);
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这里面try语句里面会抛出&java.lang.NumberFormatException，所以程序会先执行catch语句中的逻辑，t赋值为catch，在执行return之前，会把返回值保存到一个临时变量里面t '，执行finally的逻辑，t赋值为finally，但是返回值和t'，所以变量t的值和返回值已经没有关系了，返回的是catch
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (Exception e) {
t = "catch";
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这个和例2有点类似，由于try语句里面抛出异常，程序转入catch语句块，catch语句在执行return语句之前执行finally，而finally语句有return,则直接执行finally的语句值，返回finally
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (Exception e) {
t = "catch";
Integer.parseInt(null);
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这个例子在catch语句块添加了Integer.parser(null)语句，强制抛出了一个异常。然后finally语句块里面没有return语句。继续分析一下，由于try语句抛出异常，程序进入catch语句块，catch语句块又抛出一个异常，说明catch语句要退出，则执行finally语句块，对t进行赋值。然后catch语句块里面抛出异常。结果是抛出java.lang.NumberFormatException异常
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (Exception e) {
t = "catch";
Integer.parseInt(null);
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这个例子和上面例子中唯一不同的是，这个例子里面finally 语句里面有return语句块。try catch中运行的逻辑和上面例子一样，当catch语句块里面抛出异常之后，进入finally语句快，然后返回t。则程序忽略catch语句块里面抛出的异常信息，直接返回t对应的值 也就是finally。方法不会抛出异常
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (NullPointerException e) {
t = "catch";
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这个例子里面catch语句里面catch的是NPE异常，而不是java.lang.NumberFormatException异常，所以不会进入catch语句块，直接进入finally语句块，finally对s赋值之后，由try语句抛出java.lang.NumberFormatException异常。
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";
Integer.parseInt(null);
} catch (NullPointerException e) {
t = "catch";
} finally {
t = "finally";
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
和上面的例子中try catch的逻辑相同，try语句执行完成执行finally语句，finally赋值s 并且返回s ，最后程序结果返回finally
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
t = "try";return
} catch (Exception e) {
t = "catch";
} finally {
t = "finally";
String.valueOf(null);
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
这个例子中，对finally语句中添加了String.valueOf(null), 强制抛出NPE异常。首先程序执行try语句，在返回执行，执行finally语句块，finally语句抛出NPE异常，整个结果返回NPE异常。
对以上所有的例子进行总结
1 try、catch、finally语句中，在如果try语句有return语句，则返回的之后当前try中变量此时对应的值，此后对变量做任何的修改，都不影响try中return的返回值
2 如果finally块中有return 语句，则返回try或catch中的返回语句忽略。
3 如果finally块中抛出异常，则整个try、catch、finally块中抛出异常
所以使用try、catch、finally语句块中需要注意的是
1 尽量在try或者catch中使用return语句。通过finally块中达到对try或者catch返回值修改是不可行的。
2 finally块中避免使用return语句，因为finally块中如果使用return语句，会显示的消化掉try、catch块中的异常信息，屏蔽了错误的发生
3 finally块中避免再次抛出异常，否则整个包含try语句块的方法回抛出异常，并且会消化掉try、catch块中的异常
阅读(...) 评论()try-catch--finally用法_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
try-catch--finally用法
上传于||暂无简介
大小：616.00B
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢java 异常捕捉 ( try catch finally ) 你真的掌握了吗？_Java_ThinkSAAS
java 异常捕捉 ( try catch finally ) 你真的掌握了吗？
java 异常捕捉 ( try catch finally ) 你真的掌握了吗？
java 中的异常处理机制你真的理解了吗？掌握了吗？
catch 体里遇到 return 是怎么处理？ finally 体遇到 return 怎么办？finally 体里有 System.exit() 方法怎么处理？当 catch 和 finally 体里同时遇上 return 怎么办？
相信你在处理异常的时候不是每次都把它 throws 掉就完事了，很多时候异常是需要我们自己来 catch 并针对所抛出的 Exception 做一些后续的处理工作。
直接上代码，先贴下面测试需要调用的方法：
// catch 后续处理工作
public static boolean catchMethod() {
System.out.print("call catchMethod and return
// finally后续处理工作
public static void finallyMethod() {
System.out.println();
System.out.print("call finallyMethod and do something
1. 抛出 Exception，没有 finally，当 catch 遇上 return
2public static boolean catchTest() {
int i = 10 / 0;
// 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is :"+ i);
// Exception 已经抛出，没有获得被执行的机会
} catch (Exception e) {
System.out.println("-- Exception --");
return catchMethod();
// Exception 抛出，获得了调用方法并返回方法值的机会
后台输出结果：
2 -- Exception --
3call catchMethod and return
2. 抛出 Exception，当 catch 体里有 return，finally 体的代码块将在 catch 执行 return 之前被执行
2public static boolean catchFinallyTest1() {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is :"+ i);
// Exception 已经抛出，没有获得被执行的机会
} catch (Exception e) {
System.out.println("-- Exception --");
return catchMethod();
// Exception 抛出，获得了调用方法的机会，但方法值在 finally 执行完后才返回
finallyMethod();
// Exception 抛出，finally 代码块将在 catch 执行 return 之前被执行
后台输出结果：
2 -- Exception --
3call catchMethod and return
4call finallyMethod and do something
3. 不抛 Exception，当 finally 代码块里面遇上 return，finally 执行完后将结束整个方法
2public static boolean catchFinallyTest2() {
int i = 10 / 2;
// 不抛出 Exception
System.out.println("i vaule is :"+ i);
// 获得被执行的机会，但执行需要在 finally 执行完成之后才能被执行
} catch (Exception e) {
System.out.println("-- Exception --");
return catchMethod();
finallyMethod();
// finally 中含有 return 语句，这个 return 将结束这个方法，不会在执行完之后再跳回 try 或 catch 继续执行，方法到此结束，返回 false
后台输出结果：
2i vaule is : 5
4call finallyMethod and do something
4. 不抛 Exception，当 finally 代码块里面遇上 System.exit() 方法 将结束和终止整个程序，而不只是方法
2public static boolean finallyExitTest() {
int i = 10 / 2;
// 不抛出 Exception
System.out.println("i vaule is :"+ i);
// 获得被执行的机会，但由于 finally 已经终止程序，返回值没有机会被返回
} catch (Exception e) {
System.out.println("-- Exception --");
}finally {
finallyMethod();
System.exit(0);// finally 中含有 System.exit() 语句，System.exit() 将退出整个程序，程序将被终止
后台输出结果：
2i vaule is : 5
4call finallyMethod and do something
5. 抛出 Exception，当 catch 和 finally 同时遇上 return，catch 的 return 返回值将不会被返回，finally 的 return 语句将结束整个方法并返回
2public static boolean finallyTest1() {
int i = 10 / 0; // 抛出 Exception，后续处理被拒绝
System.out.println("i vaule is :"+ i);
// Exception 已经抛出，没有获得被执行的机会
} catch (Exception e) {
System.out.println("-- Exception --");
// Exception 已经抛出，获得被执行的机会，但返回操作将被 finally 截断
}finally {
finallyMethod();
// return 将结束整个方法，返回 false
后台输出结果：
2 -- Exception --
4call finallyMethod and do something
6. 不抛出 Exception，当 finally 遇上 return，try 的 return 返回值将不会被返回，finally 的 return 语句将结束整个方法并返回
2public static boolean finallyTest2() {
int i = 10 / 2;
// 不抛出 Exception
System.out.println("i vaule is :"+ i);
// 获得被执行的机会，但返回将被 finally 截断
} catch (Exception e) {
System.out.println("-- Exception --");
}finally {
finallyMethod();
// return 将结束这个方法，不会在执行完之后再跳回 try 或 catch 继续执行，返回 false
后台输出结果：
2i vaule is : 5
4call finallyMethod and do something
（假设方法需要返回值）
java 的异常处理中，
在不抛出异常的情况下，程序执行完 try 里面的代码块之后，该方法并不会立即结束，而是继续试图去寻找该方法有没有 finally 的代码块，
如果没有 finally 代码块，整个方法在执行完 try 代码块后返回相应的值来结束整个方法；
如果有 finally 代码块，此时程序执行到 try 代码块里的 return 语句之时并不会立即执行 return，而是先去执行 finally 代码块里的代码，
若 finally 代码块里没有 return 或没有能够终止程序的代码，程序将在执行完 finally 代码块代码之后再返回 try 代码块执行 return 语句来结束整个方法；
若 finally 代码块里有 return 或含有能够终止程序的代码，方法将在执行完 finally 之后被结束，不再跳回 try 代码块执行 return。
在抛出异常的情况下，原理也是和上面的一样的，你把上面说到的 try 换成 catch 去理解就 OK 了 *_*
PHP开发框架
开发工具/编程工具
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
让ThinkSAAS更好，把建议拿来。
开发客服微信}