java中关于try、catch、finally中的细节分析
java实训：异常（try-catch执行顺序与自定义异常）
java实训：异常（try-catch执⾏顺序与⾃定义异常）关键字：try:执⾏可能产⽣异常的代码catch:捕获异常finally:⽆论是否发⽣异常代码总能执⾏throws:声明⽅法可能要抛出的各种异常throw:⼿动抛出⾃定义异常⽤ try-catch-finally 异常处理：情况⼀(正常运⾏，⽆异常)：执⾏try,执⾏finally,执⾏finally块后的语句情况⼆（try中出现异常）执⾏到异常语句时（不执⾏try中异常语句之后的语句），直接跳到catch块，然后执⾏finally,再执⾏finally之后的语句public class Test2 {public static void main(String[] args) {Scanner in = new Scanner(System.in);System.out.println("请输⼊被除数：");try { // 将开始可能异常的代码放⼊tryint num1 = in.nextInt();System.out.println("接受除数");int num2 = in.nextInt();System.out.println(num1+"/"+num2+"="+num1/num2);//return;//异常块：catch和finally必须⾄少出现⼀个，try块必须有}catch (InputMismatchException e){//try中有匹配的异常，异常后的语句均不执⾏，直接调⽤catch，然后执⾏catch块之后的程序，若有异常但不匹配，不执⾏catch块，程序直接结束 System.out.println("出现错误，被除数和除数必须为整数");//e.printStackTrace();//输出异常堆栈信息，打印错误序列，调⽤过程e.getMessage();//System.exit(1);return;}catch (ArithmeticException e){System.out.println("被除数不可为0");e.printStackTrace();}finally {//⽆论是否发⽣异常，异常是否匹配，都会执⾏finally,若catch调⽤System.exit(1);finally与finally之后语句均不执⾏System.out.println("感谢使⽤");}System.out.println("finally之后语句");特殊情况之try中含有return:a.⽆异常(执⾏顺序)：1.return之前的代码2.finally3.return语句4.执⾏完成（不会执⾏return之后语句,也不会执⾏finally块之后的语句）b.有异常(执⾏顺序)：1.异常之前与异常代码2.catch语句3.finally块4.finally块之后语句5.执⾏完毕（因为异常直接跳到catch块，所以try中return不会执⾏）特殊情况之catch中含有returna.⽆异常(执⾏顺序)：1.执⾏try代码块2.执⾏finally块3.执⾏finally之后的语句4.退出（⽆异常，所以不执⾏catch，直接执⾏finally）b.有异常(执⾏顺序)：这⾥有两种情况情况⼀（异常匹配到的代码块中有return）：1.执⾏try块（异常语句后的try语句均不执⾏）2.执⾏catch块return之前的语句3.执⾏finally块4.执⾏catch中的return语句5.退出情况⼆（异常匹配到的代码块⽆有return，catch在其他chtch块中）执⾏到异常语句时（不执⾏try中异常语句之后的语句），直接跳到catch块，然后执⾏finally,再执⾏finally之后的语句catch块的执⾏原理：对于异常的捕获，可以有多个catch,对于try发⽣的异常，他会根据发⽣的异常和catch⾥⾯的异常类型进⾏匹配（按照catch块从上往下匹配，但并不会执⾏不匹配的catch块语句），当他匹配到某个catch块时，他就直接进⼊这个catch块内，忽略这个catch块后⾯的所有catch块，所以，⼀般将catch（Exception e）放在最后，catch块承先⼦类后⽗类排列。
try-catch错误处理要点
try-catch错误处理要点//代码区}catch(Exception e){//异常处理}代码区如果有错误，就会返回所写异常的处理。
首先要清楚，如果没有try的话，出现异常会导致程序崩溃。
而try则可以保证程序的正常运行下去，比如说：try{int i = 1/0;}catch(Exception e){........}一个计算的话，如果除数为0，则会报错，如果没有try的话，程序直接崩溃。
用try的话，则可以让程序运行下去，并且输出为什么出错！try catch 是捕捉try部分的异常，当你没有trycatch的时候，如果出现异常则程序报错，加上trycatch，出现异常程序正常运行，只是把错误信息存储到Exception里，所以catch是用来提取异常信息的，你可以在Catch部分加上一句System.out.println(e.T oString());，如果出现异常可以把异常打印出来java的异常处理机制(try…catch…finally)1 引子try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。
不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。
不信？那你看看下面的代码，“猜猜”它执行后的结果会是什么？不要往后看答案、也不许执行代码看真正答案哦。
如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
public class TestExceptionpublic 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=2i=1testEx2, catch exceptiontestEx2, finally; return value=falsetestEx1, catch exceptiontestEx1, finally; return value=falsetestEx, catch exceptiontestEx, finally; return value=false如果你的答案真的如上面所说，那么你错啦。
异常处理-trycatch
异常处理-trycatch ⼀:try catch是什么 try catch是java程序设计中处理异常的重要组成部分 异常是程序中的⼀些错误，有些异常需要做处理，有些则不需要捕获处理，异常是针对⽅法来说的，抛出、声明抛出、捕获和处理异常都是在⽅法中进⾏的。
try...catch 可以测试代码中的错误。
try 部分包含需要运⾏的代码，⽽catch 部分包含错误发⽣时运⾏的代码。
Java异常处理通过5个关键字try、catch、throw、throws、finally进⾏管理。
基本过程是⽤try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理； 还有以部分系统⽣成的异常在Java运⾏时⾃动抛出。
你也可以通过throws关键字在⽅法上声明该⽅法要抛出异常，然后在⽅法内部通过throw抛出异常对象。
finally语句块会在⽅法执⾏return之前执⾏。
⼆:为什么要⽤try catch Java异常处理的⽬的是提⾼程序的健壮性，你可以在catch和finally代码块中给程序⼀个修正机会，使得程序不因异常⽽终⽌或者流程发⽣以外的改变。
同时，通过获取Java异常信息，也为程序的开发维护提供了⽅便，⼀般通过异 常信息就很快就能找到出现异常的问题（代码）所在。
简单来讲，⼀是为了捕获、处理程序中不可避免所出现的异常，另⼀个重要的原因是我们不能⽆视他的存在，⼜不能把它层层往上抛，所以必需catch掉做出相应处理。
换句话 说，前段发出请求，你不能说 后台报错了，就没有然后了，成与不成，能不能得到前台要的，我们都要返回⼀个结果给他。
dao层、service层你的异常可以层层往上抛，但是controller层必须做出应对措施。
就是try catch！ 三：怎么使⽤try catch ⾸先来说⼀下异常类的层次图 1、throwable Throwable 类是 Java 语⾔中所有错误或异常的超类。
try catch finally的用法
try catch finally的用法`try-catch-finally` 是 Java 和其他一些编程语言中的一种错误处理结构。
这种结构用于捕获异常，并确保无论是否发生异常，都能执行某些清理代码。
以下是 `try-catch-finally` 的基本用法：```javatry {// 尝试执行的代码块} catch (ExceptionType1 e) {// 当发生ExceptionType1异常时，将执行此代码块} catch (ExceptionType2 e) {// 当发生ExceptionType2异常时，将执行此代码块} finally {// 无论是否发生异常，都将执行此代码块}````try` 块：包含可能会抛出异常的代码。
`catch` 块：用于捕获并处理特定的异常。
可以有多个 `catch` 块来处理不同类型的异常。
`finally` 块：无论是否发生异常，都会执行此块中的代码。
这可以用于释放资源或执行必要的清理工作。
例子：```javatry {int[] arr = new int[5];arr[10] = 100; // 这将抛出一个ArrayIndexOutOfBoundsException } catch (ArrayIndexOutOfBoundsException e) {("数组越界异常: " + ());} finally {("这是finally块。
");}```在这个例子中，由于数组越界，`try` 块中的代码将抛出一个`ArrayIndexOutOfBoundsException`。
这个异常将被 `catch` 块捕获并打印出一个消息。
无论是否发生异常，`finally` 块都将被执行并打印出 "这是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中的影响，为什么这⾥会有变化？其实问题出在参数类型上，上⼀个例⼦⽤的是基本类型，这⾥⽤的引⽤类型。
异常笔记
//关于重写和重载的区别：
//重写----两个类----继承关系,方法名形同，参数相同，返回类型相同，方法体不同
// 重写方法时需要抛出异常，，，要与原方法异常的类型一致，，或者不抛出异常
//泛化----泛指
// 狗is---a动物
// 动物是狗？
//父类引用指向子类对象
当在其他方法里面调用到抛出异常的方法，该方法体一定要处理异常（两种处理方式）
Throwable
excepiton---程序员可以控制解决的异常
error ---java虚拟机的异常
Exception
RuntimeExcepiton---------可处理也可不处理
异常-------程序运行期间的出现的错误
处理异常观察错误的名字和行号
try---catch----finally-----积极的捕获异常
throw---跳转
throws----消极的抛出异常
try--catch和throws时有什么区别：
main-----try---catch
方法里面throws-----这样的方法是必须要抛出（捕获）
ArithmeticExcepiton-----算术错误类型
ClassCastException----类型转换异常
NullpointExcepiton
/ finally---无论是否发生异常都必须执行
// 关闭已经打开的文件，删除一些临时文件 等等。。
//抽象类和接口，应该选用哪个？
//每个孩子都会犯错----父母会根据孩子犯错的类型不一样来进行相应的处理
// *写出孩子类，父母类，错误类
java知识点难点总结
java知识点难点总结Java作为一门流行的编程语言，有着广泛的应用领域和大量的开发者群体。
但是，对于初学者和甚至一些有经验的程序员来说，Java也存在着一些难点和陷阱。
本文将总结一些Java中的难点知识点，帮助读者更好地理解和掌握这门语言。
1. 异常处理Java中的异常处理是一个比较困扰程序员的难点。
在Java中，异常是一种程序运行时遇到的问题，如空指针异常、类找不到异常等。
在实际开发中，异常处理是必不可少的。
Java提供了try-catch-finally语句来处理异常，但是在实际项目中，异常可能会导致复杂的处理逻辑，需要程序员有着一定的经验和技巧来处理。
此外，Java也提供了throws和throw关键字来抛出异常和主动抛出异常，这也是初学者比较容易混淆的地方。
2. 多线程多线程是Java的一大特色，也是一大难点。
在Java中，可以通过继承Thread类或者实现Runnable接口来创建线程，但是线程的并发访问可能导致数据同步问题，需要使用synchronized关键字来解决。
而且在Java中，线程的调度、同步、死锁等问题也常常让程序员头疼。
3. 内存管理Java有自己的内存管理机制，但是并不是所有的程序员都能完全理解和掌握。
尤其是对于垃圾回收机制的工作原理和触发条件，大部分程序员只知道有垃圾回收，但是并不了解具体的内部实现。
了解垃圾回收机制对于程序员来说是非常重要的，可以避免内存泄漏和性能问题。
4. 集合框架Java提供了丰富的集合框架，如List、Set、Map等。
对于初学者来说，可能会感到困惑的是各种集合的使用场景和区别，以及集合框架的实现原理。
比如ArrayList和LinkedList的区别，或者HashMap和TreeMap的选择等。
5. 泛型泛型是Java中比较抽象和难理解的概念之一。
在Java中，泛型是一种参数化类型的概念，可以使得代码更加通用和安全。
但是对于一些初学者来说，可能会感到困惑的是泛型的通配符、类型擦除等问题。
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)。
看了一位博友的一片文章，讲解的是关于java 中关于try 、catch 、finally 中一些问题下面看一个例子（例1），来讲解java 里面中try 、catch 、finally 的处理流程 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public class TryCatchFinally {@SuppressWarnings ("finally")public static final String test() {String t = "";try {t = "try";return t;} catch (Exception e) {// result = "catch";t = "catch";return t;} 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 系统 64bitjdk信息：Java(TM) SE Runtime Environment (build1.6.0_29-b11-402-11M3527) Java HotSpot(TM) 64-Bit Server VM (build 20.4-b02-402, mixed mode)编译出来的字节码部分信息，我们只看test方法，其他的先忽略掉public static final ng.String test();Code:Stack=1, Locals=4, Args_size=00: ldc #16; //String2: astore_03: ldc #18; //String try5: astore_06: aload_07: astore_38: ldc #20; //String finally10: astore_011: aload_312: areturn13: astore_114: ldc #22; //String catch16: astore_017: aload_018: astore_319: ldc #20; //String finally21: astore_022: aload_323: areturn24: astore_225: ldc #20; //String finally27: astore_028: aload_229: athrowException table:from to target type3813 Class java/lang/Exception3824 any131924 anyLineNumberTable:line 5: 0line 8: 3line 9: 6line 15: 8line 9: 11line 10: 13line 12: 14line 13: 17line 15: 19line 13: 22line 14: 24line 15: 25line 16: 28LocalVariableTable:Start Length Slot Name Signature3270 t Ljava/lang/String;14101 eLjava/lang/Exception;StackMapTable: number_of_entries = 2frame_type = 255 /* full_frame */offset_delta = 13locals = [ 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）1public class TryCatchFinally { 2 3 @SuppressWarnings("finally") 4public static final String test() { 5 String t = ""; 6 7try { 8 t = "try";9return t;10 } catch(Exception e) {11// result = "catch";12 t = "catch";13return t;14 } finally {15 t = "finally";16return t;17 }18 }19 20public static void main(String[] args) {21System.out.print(TryCatchFinally.test());22 }2324 }这里稍微修改了第一段代码，只是在finally语句块里面加入了一个return t 的表达式。
按照第一段代码的解释，先进行try{}语句，然后在return之前把当前的t的值try保存到一个变量t'，然后执行finally语句块，修改了变量t的值，在返回变量t。
这里面有两个return语句，但是程序到底返回的是try 还是finally。
接下来我们还是看字节码信息public static final ng.String test();Code:Stack=1, Locals=2, Args_size=00: ldc #16; //String2: astore_03: ldc #18; //String try5: astore_06: goto 179: astore_110: ldc #20; //String catch12: astore_013: goto 1716: pop17: ldc #22; //String finally19: astore_020: aload_021: areturnException table:from to target type399 Class java/lang/Exception31616 anyLineNumberTable:line 5: 0line 8: 3line 9: 6line 10: 9line 12: 10line 13: 13line 14: 16line 15: 17line 16: 20LocalVariableTable:Start Length Slot Name Signature3190 t Ljava/lang/String;1061 eLjava/lang/Exception;StackMapTable: number_of_entries = 3frame_type = 255 /* full_frame */offset_delta = 9locals = [ 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 = "";try {t = "try";Integer.parseInt(null);return t;} catch (Exception e) {t = "catch";return t;} finally {t = "finally";// System.out.println(t);// return t; }}public static void main(String[] args) {System.out.print(TryCatchFinally.test());}}这里面try语句里面会抛出 ng.NumberFormatException，所以程序会先执行catch语句中的逻辑，t赋值为catch，在执行return之前，会把返回值保存到一个临时变量里面t '，执行finally的逻辑，t赋值为finally，但是返回值和t'，所以变量t的值和返回值已经没有关系了，返回的是catch例4：public class TryCatchFinally {@SuppressWarnings("finally")public static final String test() {String t = "";try {t = "try";Integer.parseInt(null);return t;} catch (Exception e) {t = "catch";return t;} finally {t = "finally";return t;}}public static void main(String[] args) {System.out.print(TryCatchFinally.test());}}这个和例2有点类似，由于try语句里面抛出异常，程序转入catch语句块，catch语句在执行return语句之前执行finally，而finally语句有return,则直接执行finally的语句值，返回finally例5：public class TryCatchFinally {@SuppressWarnings("finally")public static final String test() {String t = "";try {t = "try";Integer.parseInt(null);return t;} catch (Exception e) {t = "catch";Integer.parseInt(null);return t;} finally {t = "finally";//return t; }}public static void main(String[] args) {System.out.print(TryCatchFinally.test());}}这个例子在catch语句块添加了Integer.parser(null)语句，强制抛出了一个异常。