TRY里面有RETURN语句

合集下载

东华笔试题2

1、JA V A中的异常处理机制的简单原理和应用简单原理：每当产生异常以后，如果没有程序进行相应的处理，则程序出现中断的现象，那么，此时实际上一旦产生一个异常之后，JVM会抛出一个异常类的实例化对象，如果此时使用了try语句进行捕获的话，则可以进行异常处理，如果没有的话，则交给JVM进行处理，当try进行处理，当try语句捕获到了异常以后，会与catch中的异常类进行匹配，如果匹配成功，则使用此catch语句进行处理。

应用：简单的引用，就是在所有有throws关键字的地方加入try…catch如果按照一个标准做法的话：try ,catch,finally,throw,throws关键字应该一起使用。

2、垃圾回收的优化和原理，并考虑2种回收机制。

将无用的对象空间进行释放，两种回收：自动回收，手工调用System.gc()方法，实际上调用System.gc()就相当于调用了Runtime.Runtime().gc()方法。

3、Error和Exception有什么区别？Error表示是有JVM进行处理的,是JVM出错Exception是可以由程序进行处理的，使用try…catch进行处理4、谈谈final，finally，finalize的区别。

? Final是定义是常量、方法、类的、声明的方法不能被复写、声明的类不能被继承? Finally：是异常的统一出口? Finalize:是垃圾回收前的收尾工作，是Object类中定义的5、Anonymous Inner Class(匿名内部类)是否可以extend（继承）其他类，是否可以implements(实现) interface（接口）？允许继承或实现，因为匿名内部类就是在抽象类和接口的基础之上发展起来的6、Static Nested Class和Inner Class的不同。

|-使用Static声明的内部类就是外部类，可以通过外部类，内部类直接访问|-普通的内部类是不能够直接被外部所访问的，需要通过外部类实例再找到内部类实例7、HashMap和Hashtable的区别。

try,except,finally的用法

try,except,finally的⽤法try,except,finallytry...except形式：指定⼀个或多个异常处理器(异常⼦句).。

当在try⼦句中没有异常发⽣时,，异常处理器将不被执⾏.当在try⼦句中有异常发⽣时，⾸先会执⾏except搜索异常处理器，它会按顺序搜索直到第⼀个匹配的处理器找到为⽌.。

如果在except后⾯找到对应的异常声明，就会处理。

如果没有找到，异常就会被临时保存起来，然后去执⾏finally语句,但如果finally中产⽣了新的异常或者执⾏了return或者break语句,那么临时保存的异常将会被丢失，如果finally没有上⾯的情况，最后就会抛出保存的异常。

注意：⼀般我们会将⼀个没有指定异常的except语句, 它必须放在最后, 它会匹配任何异常并处理。

try...finally形：式指定⼀个清除处理器. 在执⾏try语句块没有异常发⽣时, finally⼦句被执⾏.在异常引发时, 该异常就被临时保存起来, finally也被执⾏, 然后暂存的异常被重新引发.如果执⾏finally⼦句时引发了另⼀个异常或执⾏了return或break语句, 就会抛弃保存的异常,在finally⼦句中的continue语句是⾮法的(这么做的原因是当前实现的原因 ---- 这个限制可能也会保留下去)在执⾏finally⼦句时异常信息是⽆效的.简单总结：1.当执⾏try...except之间的语句序列没有发⽣异常时，则忽略异常处理部分(except)的语句。

2、Except括起来的语句，则只有在产⽣异常的情况下会被执⾏，其他情况⼀概不执⾏的。

3、Finally括起来的语句是铁定会被执⾏的，⽆论是否有异常产⽣；⾯试题1def func():try:return 123finally:return 321print(func())#结果：321def func():try:return 123finally:print(321)print(func())#结果321 123finally有⼀个特性,那就是⽆论如何,finally中的代码都将被执⾏,那么当执⾏到try中return的时候函数fun将被结束返回,这个时候由于finally的特性,try中的return 'try return' 经暂时被挂起,当执⾏完finally中的语句之后再返回执⾏,可finally中却执⾏了另⼀个return,导致了函数直接结束了,此时try中的finally就被丢失了。

JAVA中try、catch、finally带return的执行顺序总结

JAVA中try、catch、finally带return的执⾏顺序总结异常处理中，try、catch、finally的执⾏顺序，⼤家都知道是按顺序执⾏的。

即，如果try中没有异常，则顺序为try→finally，如果try中有异常，则顺序为try→catch→finally。

但是当try、catch、finally中加⼊return之后，就会有⼏种不同的情况出现，下⾯分别来说明⼀下。

也可以跳到最后直接看总结。

⼀、try中带有return1private int testReturn1() {2int i = 1;3try {4 i++;5 System.out.println("try:" + i);6return i;7 } catch (Exception e) {8 i++;9 System.out.println("catch:" + i);10 } finally {11 i++;12 System.out.println("finally:" + i);13 }14return i;15 }输出：try:2finally:32 因为当try中带有return时，会先执⾏return前的代码，然后暂时保存需要return的信息，再执⾏finally中的代码，最后再通过return返回之前保存的信息。

所以，这⾥⽅法返回的值是try中计算后的2，⽽⾮finally中计算后的3。

但有⼀点需要注意，再看另外⼀个例⼦：1private List<Integer> testReturn2() {2 List<Integer> list = new ArrayList<>();3try {4 list.add(1);5 System.out.println("try:" + list);6return list;7 } catch (Exception e) {8 list.add(2);9 System.out.println("catch:" + list);10 } finally {11 list.add(3);12 System.out.println("finally:" + list);13 }14return list;15 }输出：try:[1]finally:[1, 3][1, 3] 看完这个例⼦，可能会发现问题，刚提到return时会临时保存需要返回的信息，不受finally中的影响，为什么这⾥会有变化？其实问题出在参数类型上，上⼀个例⼦⽤的是基本类型，这⾥⽤的引⽤类型。

对python中的try、except、finally执行顺序详解

对python中的try、except、finally执⾏顺序详解如下所⽰：def test1():try:print('to do stuff')raise Exception('hehe')print('to return in try')return 'try'except Exception:print('process except')print('to return in except')return 'except'finally:print('to return in finally')return 'finally'test1Return = test1()print('test1Return : ' + test1Return)输出：to do stuffprocess exceptto return in exceptto return in finallytest1Return : finally在 try 中 raise⼀个异常，就⽴刻转⼊ except 中执⾏，在except 中遇到 return 时，就强制转到 finally 中执⾏，在 finally 中遇到 return 时就返回def test2():try:print('to do stuff')print('to return in try')return 'try'except Exception:print('process except')print('to return in except')return 'except'finally:print('to return in finally')return 'finally'test2Return = test2()print('test1Return : ' + test2Return)输出：to do stuffto return in tryto return in finallytest2Return : finally这⾥在 try 中没有抛出异常，因此不会转到 except 中，但是在try 中遇到return时，也会⽴即强制转到finally中执⾏，并在finally中返回test1和test2得到的结论：⽆论是在try还是在except中，遇到return时，只要设定了finally语句，就会中断当前的return语句，跳转到finally中执⾏，如果finally中遇到return语句，就直接返回，不再跳转回try/excpet中被中断的return语句def test3():i = 0try:i += 1print('i in try : %s'%i)raise Exception('hehe')except Exception:i += 1print('i in except : %s'%i)return ifinally:i += 1print ('i in finally : %s'%i )print('test3Return : %s'% test3())输出：i in try : 1i in except : 2i in finally : 3test3Return : 2def test4():i = 0try:i += 1return ifinally:i += 1print ('i in finally : %s'%i )print('test4Return : %s' % test4())输出i in finally : 2test4Return : 1test3和test4得到的结论：在except和try中遇到return时，会锁定return的值，然后跳转到finally中，如果finally中没有return语句，则finally执⾏完毕之后仍返回原return点，将之前锁定的值返回(即finally中的动作不影响返回值)，如果finally中有return语句，则执⾏finally中的return语句。

trycatchfinally执行顺序与抛错机制

trycatchfinally执⾏顺序与抛错机制try catch finally 执⾏顺序与抛错机制⼀、结论1. try 先执⾏，若有报错，执⾏ catch2. 不管有没有异常 finally 肯定会执⾏3. try 和 catch 中存在 return 或者 throw，finally 也会执⾏4. catch 中若报错：猜测先暂存 catch 错误，等待 finally 执⾏完毕后，抛出错误5. catch 中若报错， finally 也报错：1. 猜测先暂存 catch 错误，等待 finally 执⾏，发现 finally 存在错误，直接抛出 finally 的错误2. 抛出 catch 错误的程序不会执⾏，所以最终表⽰为抛出 finally 错误，catch 错误不显⽰6. 在 try catch 中，如果碰到 return 语句:1. 先执⾏return 语句表达式，但是执⾏结果会被局部变量暂存2. 之后执⾏ finally 内容，再执⾏ return 操作，返回局部变量暂存的结果7. try 或 catch 若有 return ：暂存 return 的执⾏结果，等待 finally 执⾏完毕后，才返回 try 或 catch 中return 的执⾏结果8. try 或 catch 若有 return ，finally 也有 return：1. 暂存 try 和 catch return 的执⾏结果，等待 finally 执⾏完毕2. finally 存在 return ，直接返回 finally 的 return 值，程序提前退出⼆、场景throw 的作⽤是⼿动中断程序，抛出⼀个异常，会被捕获以下的制造⼀个异常场景可以视为throw ⼀个常量或者其他数据，所以 throw 的场景等同异常场景1、⽆错误情况1、正常执⾏2、在 try 中 return ⼀个常量3、在 try 中 return ⼀个常量, 在 finally 中 return ⼀个常量2、有错误情况1、在 try 中制造⼀个异常2、在 try、catch 中各制造⼀个异常3、在 try、catch、finally 中各制造⼀个异常4、在 try 中制造⼀个异常， catch return ⼀个常量5、在 try 中制造⼀个异常， catch return ⼀个常量，finally return ⼀个常量三、测试代码以下测试⽤例都执⾏console.log(test())1、正常执⾏let test = function() {try {console.log('try:>>', 1)} catch (e) {console.log('catch:>> ', e)} finally {console.log('finally:>> ')}}// 没有报错，正常输出// try:>> 1// finally:>>// undefined2、在 try 中 return ⼀个常量1. try 中 return 的结果被局部变量保存起来，执⾏ finally 之后再输出let test = function() {try {// 未定义 aconsole.log('try:>>', 1)return 2} catch (e) {console.log('catch:>> ', e)} finally {console.log('finally:>> ')}}// try:>> 1// finally:>>// 23、在 try 中 return ⼀个常量, 在 finally 中 return ⼀个常量1. try return 的值被局部变量保存起来，执⾏ finally 之后,2. 发现 finally 中存在 return ，直接返回 finally 的 return 结果，程序提前退出let test = function() {try {console.log('try:>>', 1)return 2} catch (e) {console.log('catch:>> ', e)} finally {console.log('finally:>> ')return 3}}// try:>> 1// finally:>>// 34、在 try 中制造⼀个异常1. try 异常被 catch 捕获，输出 try 异常，继续执⾏ finallylet test = function() {try {console.log('try:>>', a)} catch (e) {console.log('catch:>> ', e)} finally {console.log('finally:>> ')}}// catch:>> ReferenceError: a is not defined// finally:>>// undefined5、在 try、catch 中各制造⼀个异常1. try 异常被 catch 捕获，此时catch 异常，猜测先暂存 catch 错误，等待 finally 执⾏完毕后，抛出 catch 错误let test = function() {try {console.log('try:>>', a)} catch (e) {console.log('catch:>> ', e)console.log('catch:>> ', b)} finally {console.log('finally:>> ')}}// catch:>> ReferenceError: a is not defined// finally:>>// ReferenceError: b is not defined6、在 try、catch、finally 中各制造⼀个异常1. try 异常被 catch 捕获，此时 catch 异常，猜测先暂存 catch 错误，等待 finally 执⾏，发现 finally 存在错误，直接抛出 finally 的错误2. 抛出 catch 错误的程序不会执⾏，所以最终表⽰为抛出 finally 错误，catch 错误不显⽰let test = function() {try {console.log('try:>>', a)} catch (e) {console.log('catch:>> ', e)console.log('catch:>> ', b)} finally {console.log('finally:>> ')console.log('finally:>> ', c)}}// catch:>> ReferenceError: a is not defined// finally:>>// ReferenceError: c is not defined7、在 try 中制造⼀个异常， catch return ⼀个常量1. try 异常被 catch 捕获，局部变量暂存 catch return 的执⾏结果，2. 执⾏ finally 之后，返回局部变量暂存的结果let test = function() {try {console.log('try:>>', a)} catch (e) {console.log('catch:>> ', e)return 1} finally {console.log('finally:>> ')}}// catch:>> ReferenceError: a is not defined// finally:>>// 18、在 try 中制造⼀个异常， catch return ⼀个常量，finally return ⼀个常量1. try 异常被 catch 捕获，局部变量暂存 catch return 的执⾏结果，等待 finally 执⾏完毕2. finally 存在 return ，直接返回 finally 的 return 值，程序提前退出let test = function() {try {console.log('try:>>', a)} catch (e) {console.log('catch:>> ', e)return 1} finally {console.log('finally:>> ')return 2}}// catch:>> ReferenceError: a is not defined// finally:>>// 29、验证 try return 后，结果暂存，执⾏ finally 后，最后返回暂存结果let test = function() {let x = 1try {// 此处执⾏ ++x 表达式， x = 2，但是程序不会直接返回结果// ⽽是会使⽤局部变量缓存 return 的值 2// 等待 finally 执⾏完成后，再 return 缓存的局部变量值return ++x} catch (e) {} finally {// 这⾥ x = 3// x 变成了 3，但是最终函数执⾏的返回值是 2++x}// 因为上⾯ return ，此处不执⾏console.log('x :>> ', x);return x}// 最后输出结果为： 2// 分析：// 1、// try 执⾏ ++x 表达式， x = 2，但是程序不会直接返回结果// ⽽是会使⽤局部变量缓存 return 的值 2// 2、// 执⾏ finally// x = 3// 3、// finally 执⾏完成后， return 缓存的局部变量值 2// 最后输出结果为 2。

finally语句块与return的执行关系

这是一道Java面试题：try{ }里有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后?(如果try后面有个catch块，里面有return语句，那么finally语句会不会执行？)finally语句块的作用就是为了保证无论出现什么情况，一定要执行的，那么finally里的code 肯定会执行，并且是在return前执行。

（只要语句执行了，肯定是在return前执行的。

finally 中也可以有return，并且会覆盖其他的return）根据java规范：在try-catch-finally中，如果try-finally或者catch-finally 中都有return，则两个return语句都执行并且最终返回到调用者那里的是finally中return的值；而如果finally中没有return，则理所当然的返回的是try或者catch中return的值，但是finally中的代码是必须要执行的,方法在return的时候并不是把它所拥有的那个值给返回了，而是复制一份返回！因此，对于基本类型的数据，在finally中改变return的值对返回值没有任何影响，而对于引用类型的数据，就有影响。

（JAVA中基本类型变量存储在___中，引用类型的对象存储在____中，对象的引用地址存储在____中。

A. 堆B. 栈C. 寄存器D. 静态存储区BBA基本类型和对象的引用都放在栈中，new出的对象和数组放在堆中）public class FinallyTest{public static void main(String[] args) {System.out.println("x的值是"+new FinallyTest().test());;}@SuppressWarnings("finally")static int test(){int x = 1;try{//x++;return x;}finally{++x;System.out.println("x的值当前值是" +x);//return x;}}}执行结果：x的值当前值是2x的值是1若finally中包含return语句public class FinallyTest{public static void main(String[] args) {System.out.println("x的值是"+new FinallyTest().test());;}@SuppressWarnings("finally")static int test(){int x = 1;try{//x++;return x;}finally{++x;System.out.println("x的值当前值是" +x);return x;}}}执行结果是：x的值当前值是2x的值是2若引用类型的数据，就有影响，public class FinallyTest4 {public static void main(String[] args) {System.out.print("k的最终返回值是： "+tt());}public static StringBuffer tt() {StringBuffer k = new StringBuffer();try {k.append(2);return k;} catch(Exception e){k.append(3);return k;} finally {k.append(5);}}}执行结果是：的最终返回值是： 25补充：java存储数据的地方以及java九种基本类型2009-12-14 10:09程序运行时6个不同地方可以存储数据：1、寄存器（register）：这是最快的存储区——处理器内部。

TRY里面有RETURN语句

java中异常处理中return的用法关于try、catch、finally语句块中含有return语句的几点说明：1、第一种情况：try块有return语句，catch块没有return，函数末尾也没有return：看代码：import java.util.*;public class demo{public static void main(string args[]){int num = 10;test(num);}public static int test(int b){try{b += 10;return b;}catch(exception e){}finally{}}}编译结果：h:\java demo>javac demo.javademo.java:18: 缺少返回语句}^1 错误有人可能会说，我在try块中不是有return语句吗？为什么会提示缺少return语句呢？这是因为编译器认为try块中是又可能产生异常操作的，也就是说在return语句之前如果出现异常的话，那么return语句根本没有机会得到执行，所以编译器会认为缺少return语句。

解决办法:a、在catch块中加入return语句，因为一旦出现异常，catch中的语句可以保证函数会有一个返回值b、在finally块中加入return语句，同样只要系统不退出，finally语句块会始终得到执行的代码：import java.util.*;public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){try{b += 10;return b;}catch(exception e){}finally{ return 0;}}}c、在函数末尾加入return语句代码：import java.util.*;public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){ try{b += 10;return b;}catch(exception e){}finally{}return 0;}}2、第二种情况，看代码：import java.util.*;public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){try{b += 10;}return 0;}}结果：h:\java demo>javac demo.javademo.java:8: try 不带有 catch 或 finallytry{^1 错误说明：也就是说，如果有try语句的话，可以有catch语句，没有finally语句，但是如果没有catch语句的话，那么一定要有finally语句。

trycatchfinally的理解

trycatchfinally的理解定义以及⽤法：try/catch/finally 语句⽤于处理代码中可能出现的错误信息。

错误可能是语法错误，通常是程序员造成的编码错误或错别字。

也可能是拼写错误或语⾔中缺少的功能（可能由于浏览器差异）。

try语句允许我们定义在执⾏时进⾏错误测试的代码块。

catch 语句允许我们定义当 try 代码块发⽣错误时，所执⾏的代码块。

finally 语句在 try 和 catch 之后⽆论有⽆异常都会执⾏。

注意： catch 和 finally 语句都是可选的，但你在使⽤ try 语句时必须⾄少使⽤⼀个。

提⽰：当错误发⽣时， JavaScript 会停⽌执⾏，并⽣成⼀个错误信息。

使⽤语句来创建⾃定义消息(抛出异常)。

如果你将 throw 和 try 、catch⼀起使⽤，就可以控制程序输出的错误信息。

总结：try { //执⾏的代码，其中可能有异常。

⼀旦发现异常，则⽴即跳到catch执⾏。

否则不会执⾏catch⾥⾯的内容 }catch { //除⾮try⾥⾯执⾏代码发⽣了异常，否则这⾥的代码不会执⾏ }finally { //不管什么情况都会执⾏，包括try catch ⾥⾯⽤了return ,可以理解为只要执⾏了try或者catch，就⼀定会执⾏ finally }案例：1 2 3 4 5 6 7 8 9 10(function(){try{throw new Error();}catch(x){var x = 1, y = 2;console.log(x); // 1}console.log(x); //undefined console.log(y); //2}());下⾯说⼀下js错误Error对象的详解：　⼀·概念error，指程序中的⾮正常运⾏状态，在其他编程语⾔中称为“异常”或“错误”。

解释器会为每个错误情形创建并抛出⼀个Error对象，其中包含错误的描述信息。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

并且如果出现catch语句的话，catch语句可以出现多次，而finally语句只能出现一次。

代码：public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){ try{b += 10;}catch(runtimeexception e){}catch(exception e2){}finally{}return 0;}}3、第三种情况：a、try块中有return语句，那么是先执行return语句，还是先执行finally语句。

大家通常会有一个错误的认识，可能有的老师都会讲错，认为是先执行finally语句，再执行return语句，但是这是错误的，事实上是先执行return语句，再执行finally语句，然后将结果返回，也可以说return语句执行了两次，一次在finally之前，一次在finally之后，但是返回的确是第一次执行的值，如果有不信的，请继续看代码，此段代码可以证明我的观点：代码：public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){try{b += 10;return b;}catch(runtimeexception e){}catch(exception e2){ }finally{b += 10;}return 0;}}结果：h:\java demo>javac demo.javah:\java demo>java demo 20说明：此处需要引入缓冲的概念，有对缓冲不太了解的也没关系，程序运行结果是20足以证明我的观点，程序执行流程是进入try语句块执行return语句，但是程序有finally语句块，所有先将return返回的值缓冲起来，然后程序跳转到finally语句块执行，我在finally语句块中修改了变量b的值，但是程序返回的依然是20，并不是30，说明finally语句块执行完毕后，程序直接将之前缓冲的值返回了。

所以这就是真实的执行流程。

b、try块中有return，finally语句块中也有return，此时的情况是什么样呢？看代码：public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){try{b += 10;return b;}catch(runtimeexception e){}catch(exception e2){}finally{b += 10;return b;}} }结果是：h:\java demo>java demo30说明：为什么此时结果是30了呢，大家都知道return语句的作用是结束程序体，所以此段代码依然是先执行try块中的return语句，并将20缓存起来，接着跳转到finally语句块执行，但是由于finally语句块中有return语句，所以程序在此处结束，并不返回到try块中返回结果，而是直接将finally块中新修改的值即30，返回。

c、try块中有return语句，catch块中也有return语句，这时候是最简单的一种情况：看代码：public class demo{public static void main(string args[]){int num = 10;system.out.println(test(num));}public static int test(int b){try{int a = b/0;return b;}catch(exception e2){b += 10;return b;}}}结果：h:\java demo>java demo20说明：我在try块中触发了一个异常，程序跳入catch语句块，try语句块中剩篇二：try finally内有return的情况总结「java」 try、finally语句块内有 return 的注意问题情况一：（最普通用法）public class test {public static void main(string[] args) {system.out.print(tt());}public static int tt() {int b = 23;try {system.out.println(yes);return b += 88;} catch(exception e) {system.out.println(error: + e);} finally {if (b > 25) {system.out.println(b>25: + b);}system.out.println(finally);}return b;}}输出(开始)yesb>25:111finally111输出(结束)结论1 ：说明finally语句在return语句执行完了以后才执行的.情况二：（finally中有return语句）修finally部分public static int tt() {int b = 23;try {system.out.println(yes);return b += 88;} catch(exception e) {system.out.println(error: + e);} finally {if (b > 25) {system.out.println(b>25: + b);}system.out.println(finally);return 100;}}输出(开始)yesb>25:111finally100输出(结束)结论2：这样又说明了一个问题,finally语句块里面的return把原来的return给覆盖了，变成了新的返回值了.情况三：（finally内改变返回值的value，但不返回）继续修改输出(开始)yesfinally23输出(结束)结论3：如果finally语句中没有返回语句覆盖的话，那么原来的返回值就不会变,不管你是不是改变了要返回的那个变量.public static int tt() {} int b = 23; try {} return b; system.out.println(yes); return b; system.out.println(error: + e); if (b > 25) { } system.out.println(finally); b = 100; system.out.println(b>25: + b); } catch (exception e) { } finally {情况四：（在try、finally外，返回一个值，会不会改变try、finally内的返回值）输出(开始)yesb>25 : 88finally88输出(结束)结论4 ：如果try、finally内已经有return，则外部的return不会起作用。