下载文档原格式
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中的异常处理x=n.nextInt();if(x!=999)sum+=x;}catch(InputMismatchException e){}System.out.println(sum);}}}class TestXin{/*** @param args*/public static void main(String[] args) { // TODO Auto-generated method stubXin n=new Xin();System.out.println(n);}}结果:五、实验总结（对本实验结果进行分析, 实验心得体会及改进意见）5.分析程序的运行结果（1）class A{A(){System.out.println("A structure!");}A(int m){System.out.println("A("+m+")");}}public class B extends A{B(int m){System.out.println("B("+m+")");}public static void main(String[] args) { // TODO Auto-generated method stubnew B(100);}}（2）class A{A(){System.out.println("A structure!");}A(int m){System.out.println("A("+m+")");}}public class B extends A{B(){System.out.println("B structure!");}B(int m){System.out.println("B("+m+")");}public static void main(String[] args) { // TODO Auto-generated method stubnew B(100);}}（3）class A{A(){System.out.println("A structure!");}A(int m){System.out.println("A("+m+")");}}public class B extends A{B(){System.out.println("B structure!");}B(int m){//super(m);System.out.println("B("+m+")");}public static void main(String[] args) { new B(100);}}（4）class A{A(){System.out.println("A structure!");}A(int m){System.out.println("A("+m+")");}}public class B extends A{B(int m){super(m);//System.out.println("B("+m+")");}public static void main(String[] args) { new B(100);} }。
ng.exception 的方法ng.Exception类是Java程序中常用的一个异常类，它是所有异常的根类，也是Java编程中异常处理的基础。
在本文中，我们将介绍ng.Exception 类的一些常用方法，并逐步分析其用法。
1. getMessage()方法：Exception类中的getMessage()方法用于获取异常的详细描述信息。
它返回一个字符串，其中包含了关于异常的相关信息。
我们可以通过调用该方法，捕获并获取到异常的具体信息，从而进行后续的处理和分析。
以下是一个示例代码：javatry {代码块} catch (Exception e) {System.out.println(e.getMessage());}在这个示例中，如果try块中抛出了一个异常，那么这个异常会被catch块捕获，并调用getMessage()方法打印出异常的信息。
2. toString()方法：Exception类中的toString()方法用于返回一个包含异常类名和异常信息的字符串。
它的返回值是一个字符串，格式如下：ExceptionClassName : ExceptionMessage。
这个方法可以方便地打印出异常的详细信息，例如堆栈轨迹和错误消息。
以下是一个示例代码：javatry {代码块} catch (Exception e) {System.out.println(e.toString());}在这个示例中，如果try块中抛出了一个异常，那么这个异常会被catch块捕获，并调用toString()方法打印出异常的详细信息。
3. printStackTrace()方法：Exception类中的printStackTrace()方法用于打印出异常信息的完整堆栈轨迹。
它会输出异常发生的位置，以及异常的原因和导致异常的方法调用链。
这个方法可以帮助我们快速定位到异常的发生位置，并进行相关调试和排查。
以下是一个示例代码：javatry {代码块} catch (Exception e) {e.printStackTrace();}在这个示例中，如果try块中抛出了一个异常，那么这个异常会被catch块捕获，并调用printStackTrace()方法打印出异常的完整堆栈轨迹信息。
java 编程中关于异常处理的 10 个最佳实践在Java编程中，异常处理是一项重要的技术，可以帮助我们提高程序的稳定性和可靠性。
下面列出了10个Java编程中的异常处理最佳实践，以帮助开发者在处理异常时写出更健壮的代码。
1.使用具体的异常类型在捕获异常时，应该尽量使用具体的异常类型而不是通用的Exception类。
这样可以提供更多相关的上下文信息，并且能够针对特定的异常类型采取特定的处理措施。
```javatry {//一些可能抛出特定异常的代码} catch (IOException e) {//处理IOException} catch (SQLException e) {//处理SQLException} catch (Exception e) {//处理其他异常}```2.避免捕获所有异常捕获所有异常可能会导致难以调试的问题，并掩盖真正的问题。
应该尽量只捕获我们能够处理的异常，并将其他异常向上层抛出。
```javatry {//一些可能抛出异常的代码} catch (SpecificException e) {//处理特定异常// ...} finally {//执行清理操作}```3.及早捕获异常尽可能在代码中的早期捕获异常，以便及时处理和回滚。
如果异常延迟到了较迟的阶段再捕获，可能会增加处理异常的复杂性。
4.不要忽略异常在捕获异常时，不要简单地什么也不做，或者只打印一条错误信息。
应该根据具体情况采取适当的处理措施，例如回滚操作，记录日志或重新抛出异常。
```javatry {//一些可能抛出异常的代码} catch (SpecificException e) {//处理特定异常// ...//例如回滚数据库操作} catch (Exception e) {//处理其他异常// ...//例如记录日志logger.error("An error occurred", e);}```5.使用finally块进行清理操作在异常处理中，finally块可以确保资源的正确释放，不管是否发生异常都会执行其中的代码。
java中catch的用法Java中的异常处理是一种非常重要的机制。
开发者需要在代码中预测并处理可能出现的异常情况，从而避免程序出现不可预知的意外情况。
在异常处理中，try-catch语句是最常用的方法之一。
本文将详细介绍Java中catch的用法。
1. catch语句的基本语法catch语句是try-catch语句中的一个关键组成部分。
catch语句用来捕获可能在try 语句块中抛出的异常，并根据异常类型进行处理。
catch语句的基本语法如下：```try{//需要进行异常处理的代码块//可能会抛出异常的代码}catch(ExceptionType1 e1){// 异常类型1的处理代码}catch(ExceptionType2 e2){// 异常类型2的处理代码}…catch(ExceptionTypeN eN){// 异常类型N的处理代码}finally {//finally语句块}```上述基本语法包含三部分：try语句块、一个或多个catch语句块和finally语句块。
其中，try块中包含需要进行异常处理的代码，一旦其中的代码抛出了异常，就会进入对应的catch语句块中进行处理。
当无论try代码块中是否出现异常情况，finally语句块都将会被执行。
catch语句块包含一个异常类型和一段相应的代码。
当try块中抛出的异常类型和其中某一个catch块中定义的类型匹配时，相应的catch块中的代码将被执行。
java中定义的异常类型有很多，如NullPointerException（空指针异常）、NumberFormatException（数字格式异常）、ArrayIndexOutOfBoundsException（数组下标越界异常）等等。
开发者可以根据实际的程序需求来选择对应的异常类型。
2. 捕获多个异常类型Java中catch语句的“多重捕获”功能可以让开发人员在一个try块中一次性捕获多种类型的异常。
java异常处理实验报告Java异常处理实验报告一、实验目的本次实验旨在通过编写Java程序，学习和掌握异常处理的相关知识和技巧，提高代码的健壮性和可靠性。
二、实验环境本次实验使用的开发环境为Eclipse，使用Java语言进行编程。
三、实验内容1. 异常的概念异常是指程序在运行过程中出现的意外情况，例如除零错误、数组越界等。
Java中的异常是以类的形式存在的，所有异常类都是Throwable类的子类。
2. 异常处理的方法Java提供了try-catch-finally语句用于处理异常。
在try块中编写可能会抛出异常的代码，如果发生异常，则会跳转到对应的catch块进行处理。
finally块中的代码无论是否发生异常都会被执行。
3. 异常的分类Java中的异常分为两种类型：受检异常（Checked Exception）和非受检异常（Unchecked Exception）。
受检异常需要在代码中显式地进行处理，否则编译器会报错；而非受检异常不需要强制处理。
4. 自定义异常除了使用Java提供的异常类，我们还可以根据需要自定义异常类。
自定义异常类需要继承Exception类或RuntimeException类，并重写相应的方法。
5. 异常处理的最佳实践在实际的软件开发中，异常处理是非常重要的一部分。
以下是一些异常处理的最佳实践：- 尽早捕获异常：在代码中尽量早地捕获异常，以避免异常的传播和影响其他部分的代码。
- 适当处理异常：根据具体情况，选择合适的处理方式，可以是打印日志、返回默认值、抛出新的异常等。
- 避免捕获过宽的异常：捕获异常时要尽量精确，避免捕获过宽的异常类型，以免屏蔽了真正的问题。
四、实验步骤1. 创建一个Java项目，并新建一个类用于实现异常处理的实验。
2. 编写代码，在try块中编写可能会抛出异常的代码。
3. 使用catch块捕获异常，并进行相应的处理，例如打印异常信息。
4. 在finally块中编写必要的代码，例如资源的释放。
Java线程池未捕获异常处理方法在Java编程中，使用线程池是一种常见的方式来管理和调度多线程任务。
然而，线程池的异常处理却是一个容易被忽视的问题。
在本文中，我将从多个角度探讨Java线程池未捕获异常处理方法，帮助读者更全面、深入地理解这一主题。
1.理解线程池未捕获异常在深入讨论处理方法之前，我们需要首先理解线程池未捕获异常的概念。
在线程池中，如果一个线程由于未捕获的异常而突然终止，该异常将会导致整个线程池停止工作，从而影响到整个应用程序的稳定性和可靠性。
处理线程池未捕获异常变得至关重要。
2.使用Thread.UncaughtExceptionHandler处理线程池异常Java提供了Thread.UncaughtExceptionHandler接口，用于处理线程未捕获异常。
我们可以通过实现该接口来定义自己的异常处理逻辑，从而更好地控制线程池的异常情况。
在实际应用中，我们可以通过以下步骤来处理线程池未捕获异常：- 实现Thread.UncaughtExceptionHandler接口，并重写uncaughtException方法，在该方法中编写自定义的异常处理逻辑。
- 在创建线程池时，使用ThreadFactory指定线程工厂并设置自定义的UncaughtExceptionHandler。
3.使用CompletableFuture处理线程池异常除了使用Thread.UncaughtExceptionHandler之外，我们还可以通过CompletableFuture来处理线程池的异常。
CompletableFuture 是Java 8中引入的一个重要类，它提供了一种简洁、优雅的方式来处理异步计算和异常情况。
在处理线程池未捕获异常时，我们可以通过CompletableFuture的exceptionally方法来捕获并处理异常，从而保证线程池的稳定性和可靠性。
4.结合日志记录和监控系统除了在代码中处理线程池未捕获异常之外，我们还可以结合日志记录和监控系统来更好地掌握线程池的异常情况。
程序设计中的异常处理与错误调试在程序设计中，异常处理和错误调试是非常重要的环节。
合理地处理异常和调试错误可以提高程序的稳定性和可靠性。
本文将从以下几个方面探讨程序设计中的异常处理和错误调试。
一、异常处理的重要性异常是指在程序运行过程中出现的与正常流程不符的事件或情况。
有些异常是可以预料到的，例如除零错误、空指针异常等；而有些异常是难以预料到的，例如网络连接中断、硬盘损坏等。
无论是预料到的异常还是难以预料到的异常，都需要在程序中进行相应的处理。
正确地处理异常能够使程序在出现错误或异常时能够正常终止，避免程序崩溃或产生不可预料的结果。
异常处理还能提高程序的容错性，使程序能够更好地适应各种环境和情况。
二、异常处理的常用方法在程序中，我们通常使用try-catch语句块来处理异常。
try语句块用于包裹可能会抛出异常的代码，而catch语句块用于捕获并处理异常。
例如，当我们打开一个文件时，可能会抛出FileNotFoundException异常。
我们可以使用try-catch语句块来捕获该异常，并在catch语句块中进行相应的处理，例如打印错误信息或进行文件的备份操作。
除了try-catch语句块，我们还可以使用finally语句块来执行一些无论是否发生异常都需要执行的代码，例如关闭数据库连接或释放资源等。
三、错误调试的方法在程序设计中，错误调试是我们经常需要进行的工作。
调试错误可以帮助我们找到程序的问题所在，并对其进行修复。
1. 日志记录日志记录是一种常用的错误调试方法。
我们可以在程序中插入合适的日志语句，记录程序运行过程中的关键信息，例如变量的取值、函数的调用等。
通过查看日志信息，我们可以追踪程序的执行流程，找到程序出错的原因。
2. 断点调试断点调试是调试器提供的一种常用调试方法。
我们可以在程序中设置断点，当程序执行到断点处时，会中断执行，我们可以查看当前变量的取值、执行路径等信息。
通过断点调试，可以逐步调试程序，找到错误所在。
Java中，e.getMessage()是一个常用的方法，用于获取异常的详细信息。
在程序中，当出现异常时，我们可以使用该方法来获取异常的描述，以便进行相应的处理。
下面将介绍e.getMessage()的具体用法以及相关注意事项。
一、e.getMessage()的基本用法1. e.getMessage()是Throwable类中定义的一个方法，因此它可以在所有的异常类中使用。
2. 该方法的返回值类型为String，即异常的详细信息会以字符串的形式返回。
3. 在捕获异常后，通过调用e.getMessage()方法，可以获取异常的描述信息，这对于调试和定位问题非常有帮助。
二、示例代码下面是一个简单的示例代码，演示了如何使用e.getMessage()方法来获取异常信息。
```javapublic class Demo {public static void m本人n(String[] args) {try {int result = 10 / 0;} catch (ArithmeticException e) {System.out.println("发生异常：" + e.getMessage());}}}```在上面的示例中，当除数为0时会抛出ArithmeticException异常，在捕获该异常后，通过调用e.getMessage()方法，输出异常信息到控制台。
三、注意事项1. 在使用e.getMessage()方法时，需要注意异常对象e是否为空，即在调用该方法之前需要对异常进行有效性检查，避免空指针异常的发生。
2. e.getMessage()方法返回的信息是由异常类的toString()方法返回的详细信息，因此有些异常可能返回的信息并不够清晰明了，需要根据具体情况来选择是否使用该方法。
3. 在实际开发中，可以根据业务需求自定义异常类，并重写toString()方法，以便返回更加详细和有用的异常信息。
Java中异常的捕获与处理⼀、Java异常简介什么是异常？程序运⾏时，发⽣的不被期望的事件，它阻⽌了程序按照程序员的预期正常执⾏，这就是异常。
异常发⽣时，是任程序⾃⽣⾃灭，⽴刻退出终⽌。
在Java中即，Java在编译或运⾏或者运⾏过程中出现的错误。
Java提供了更加优秀的解决办法：异常处理机制。
异常处理机制能让程序在异常发⽣时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最⼤可能恢复正常并继续执⾏，且保持代码的清晰。
Java中的异常可以是函数中的语句执⾏时引发的，也可以是程序员通过throw 语句⼿动抛出的，只要在Java程序中产⽣了异常，就会⽤⼀个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。
Java异常机制⽤到的⼏个关键字：try、catch、finally、throw、throws。
try -- ⽤于监听。
将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发⽣异常时，异常就被抛出。
catch -- ⽤于捕获异常。
catch⽤来捕获try语句块中发⽣的异常。
finally -- finally语句块总是会被执⾏。
它主要⽤于回收在try块⾥打开的物⼒资源(如数据库连接、⽹络连接和磁盘⽂件)。
只有finally 块，执⾏完成之后，才会回来执⾏try或者catch块中的return或者throw语句，如果finally中使⽤了return或者throw等终⽌⽅法的语句，则就不会跳回执⾏，直接停⽌。
throw -- ⽤于抛出异常。
throws -- ⽤在⽅法签名中，⽤于声明该⽅法可能抛出的异常。
主⽅法上也可以使⽤throws抛出。
如果在主⽅法上使⽤了throws抛出，就表⽰在主⽅法⾥⾯可以不⽤强制性进⾏异常处理，如果出现了异常，就交给JVM进⾏默认处理，则此时会导致程序中断执⾏。
产⽣异常的原因：⽤户输⼊了⾮法数据。
要打开的⽂件不存在。
javatry方法javatry方法是Java语言中的一个关键字，用于异常处理。
在Java 中，异常是指程序在运行过程中遇到的错误或异常情况，而异常处理则是针对这些异常情况的处理方式。
在Java中，异常处理是通过try-catch语句来实现的。
try块中包含可能会发生异常的代码，而catch块则用于捕获并处理这些异常。
当程序在try块中发生异常时，会跳转到catch块中执行相应的处理逻辑。
使用try-catch语句的格式如下：```try {// 可能会发生异常的代码} catch (ExceptionType1 e1) {// 处理 ExceptionType1 异常的逻辑} catch (ExceptionType2 e2) {// 处理 ExceptionType2 异常的逻辑} finally {// 可选的 finally 块，用于执行一些必须的清理工作}```在try块中，可以包含多个可能会抛出异常的语句，每个语句之间用分号分隔。
当程序执行到抛出异常的语句时，会跳转到对应的catch块中执行相应的处理逻辑。
catch块中的参数指定了要捕获的异常类型，只有当抛出的异常类型与catch块中指定的类型匹配时，才会执行该catch块中的代码。
在catch块中，可以根据实际需求进行异常处理。
可以输出错误信息、记录日志、进行重试等操作。
在处理完异常后，程序会继续执行catch块后面的代码。
除了catch块外，还可以使用finally块来执行一些必须的清理工作，无论是否发生异常都会执行finally块中的代码。
finally块通常用于释放资源、关闭文件、关闭数据库连接等操作。
在使用try-catch语句时，需要注意以下几点：1. 异常处理应该具体到每个可能发生异常的地方，而不是简单地捕获所有异常。
2. 多个catch块的顺序应该从具体到一般，即应该先捕获具体的异常类型，再捕获一般的异常类型。
3. 可以在catch块中使用多个catch语句来处理不同类型的异常。
Java 异常和本地（Native）异常捕获的原理略有不同。
Java 异常：Java 异常是在 Java 虚拟机（JVM）中处理的，其基本原理如下：1.抛出异常：当 Java 代码中发生异常时，会创建一个异常对象，该对象包含异常的类型和相关信息。
然后，这个异常对象被抛出（throw）。
2.异常传播：异常沿着调用堆栈传播，直到找到一个能够处理该异常的地方。
这个地方可以是当前方法内的 catch 块，也可以是调用栈的上层方法。
3.捕获异常：如果异常找到了一个匹配的 catch 块，该块将被执行。
如果没有找到匹配的 catch 块，程序会终止并输出异常信息。
本地异常（Native Exception）：本地异常通常是指在调用本地方法（Native Method）时发生的异常，即在 Java 代码中调用了由本地语言（如C或C++）编写的方法。
在这种情况下，异常处理的流程与 Java 异常有所不同。
1.本地方法调用： Java 代码通过 JNI（Java Native Interface）调用本地方法。
2.本地方法执行：本地方法在本地语言中执行，并且如果在本地方法中发生异常，该异常并不会被 JVM 直接捕获。
3.异常处理：本地异常的处理通常由本地语言的异常处理机制负责。
例如，在 C 或 C++ 中，可能会使用 try-catch 块来处理异常。
因此，Java 代码无法直接捕获本地异常。
为了在 Java 代码中处理本地异常，本地方法通常会提供一些接口，以允许 Java 代码查询本地方法是否发生异常，然后通过 Java 异常机制捕获和处理这些异常。
总体来说，Java 异常是在 JVM 中处理的，而本地异常是在本地方法的执行环境中处理的，两者之间存在一定的隔离。
java异常处理机制详解转⾃：/hy928302776/archive/2013/04/22/3035504.html异常机制已经成为判断⼀门编程语⾔是否成熟的标准，异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提⾼程序健壮性。
Java异常机制主要依赖于try、catch、finally、throw、throws五个关键字。
1.try：它⾥⾯放置可能引发异常的代码2.catch：后⾯对应异常类型和⼀个代码块，⽤于表明该catch块⽤于处理这种类型的代码块，可以有多个catch块。
3.finally：主要⽤于回收在try块⾥打开的物⼒资源（如数据库连接、⽹络连接和磁盘⽂件），异常机制总是保证finally块总是被执⾏。
只有finally 块，执⾏完成之后，才会回来执⾏try或者catch块中的return或者throw语句，如果finally中使⽤了return或者 throw等终⽌⽅法的语句，则就不会跳回执⾏，直接停⽌。
4.throw：⽤于抛出⼀个实际的异常，可以单独作为语句使⽤，抛出⼀个具体的异常对象。
5.throws：⽤在⽅法签名中，⽤于声明该⽅法可能抛出的异常。
Java的异常分为两种，checked异常（编译时异常）和Runtime异常（运⾏时异常）1. java认为checked异常都是可以再编译阶段被处理的异常，所以它强制程序处理所有的checked异常，⽽Runtime异常⽆须处理，java程序必须显式处理checked异常，如果程序没有处理，则在编译时会发⽣错误，⽆法通过编译。
2. checked异常体现了java设计哲学：没有完善处理的代码根本不会被执⾏，体现了java的严谨性，对于构造⼤型、健壮、可维护的应⽤系统⽽⾔，错误处理是整个应⽤需要考虑的重要⽅⾯。
Java异常处理机制，在程序运⾏出现意外时，系统会⽣成⼀个Exception对象，来通知程序，从⽽实现将“业务功能实现代码”和“错误处理代码”分离，提供更好的可读性。
Java捕获异常处理的常用方法
在Java中，异常情况分为Exception（异常）和Error（错误）两大类，Java 异常通常是指程序运行过程中出现的非正常情况，如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等，对于异常情况的出现，可以采用异常处理，以保证程序可以正常的执行。
Java中定义两种类型的异常和错误：
1. JVM(Java虚拟机) 异常：由JVM 抛出的异常或错误。
例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。
2. 程序级异常：由程序或者API程序抛出的异常。
例如IllegalArgumentException 类，IllegalStateException 类。
捕获异常的方法
使用 try 和 catch 关键字可以捕获异常，try/catch代码块中的代码称为保护代码，可以放在异常可能发生的地方，具体用法如下：
try
{
// 程序代码
}catch(ExceptionName e1)
{
//Catch 块
}
catch 语句包含要捕获异常类型的声明。
当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。
也可以进行多重捕获，具体用法是在try代码块后面跟随多个catch代码块。
catch 语句往往是和finally配合使用，finally关键字用来创建在try代码块后面执行的代码块，无论是否发生异常，finally代码块中的代码总会被执行，因此，在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
声明自定义异常
在Java中可以自定义异常，在自定义异常类时需注意以下几点：
1. 所有异常都必须是 Throwable 的子类；
2. 自定义检查性异常类，则需继承 Exception 类；
3. 自定义运行时异常类，则需继承 RuntimeException 类。
自定义的异常类和其他任何类都一样，包含有变量和方法。
其作用机制均是抛出异常和捕捉异常，一个方法能捕捉异常，一定是Java代码在某处所抛出的异常，异常总是先被抛出，后被捕捉的。
