下载文档原格式
异常处理结构举例异常处理是编程中非常重要的一部分，它能够帮助我们在程序运行过程中发现和解决错误，提高程序的健壮性和稳定性。
下面我将举例介绍一些常见的异常处理结构。
1. try-catch-finally结构：这是最常见的异常处理结构，用于捕获并处理异常。
try块中包含可能会抛出异常的代码，catch块用于捕获并处理异常，finally块中的代码无论是否抛出异常都会执行。
例如：```javatry {// 可能会抛出异常的代码} catch (Exception e) {// 异常处理逻辑} finally {// 最终执行的代码}```2. try-with-resources结构：用于自动关闭资源，比如文件、数据库连接等。
在try块中创建的资源会在代码块结束后自动关闭，无需手动调用关闭方法。
例如：try (FileInputStream fis = new FileInputStream("file.txt")) {// 使用文件流的代码} catch (IOException e) {// 异常处理逻辑}```3. throw语句：用于手动抛出异常，可在方法中根据特定条件抛出异常。
例如：```javapublic void divide(int a, int b) throws ArithmeticException {if (b == 0) {throw new ArithmeticException("除数不能为0");}int result = a / b;System.out.println("结果：" + result);}```4. throws关键字：用于方法声明中，表示该方法可能会抛出异常，需要调用该方法的地方处理异常。
例如：public void readFile() throws IOException {// 可能会抛出IOException的代码}```5. 自定义异常类：除了使用Java提供的异常类，我们还可以自定义异常类来满足特定的需求。
软件开发中的异常处理工具与技巧介绍：在软件开发过程中，异常处理是一个必不可少的环节。
合理处理异常能够提高软件的稳定性和可靠性，保证系统运行的平稳和用户体验的良好。
本篇文章将探讨一些常见的异常处理工具与技巧，帮助开发者更好地应对各种异常情况。
一、Logging工具Logging工具在异常处理中扮演着重要的角色。
通过记录软件运行时的日志信息，开发者能够更好地追踪问题以及定位异常发生的原因。
常见的Logging工具有log4j、logback等。
使用这些工具，开发者可以将异常信息和报错信息输出到日志文件中，便于后续分析和处理。
二、断言（Assert）断言是一种常用的异常处理技巧。
开发者可以在代码中插入断言语句，验证某些前提条件是否满足，如果不满足则抛出异常。
通过这种方式，开发者可以快速发现问题并及时处理。
Java语言提供了assert关键字，可以方便地在代码中使用断言。
三、错误码与异常分类在软件开发过程中，定义一套错误码和异常分类是很有必要的。
通过给不同的异常分配错误码，开发者可以快速定位问题所在，进行相应的处理。
同时，通过合理分类异常，开发者能够更好地理清业务逻辑，使代码更易读、易维护。
四、异常处理框架异常处理框架是一种常见的异常处理工具。
不同的语言和框架都提供了各自的异常处理机制。
例如在Java中，我们可以使用try-catch-finally语句块来捕获和处理异常。
同时，Java还提供了throw 和throws关键字，可以实现异常的抛出和传递。
在框架层面，Spring 等提供了一些强大的异常处理能力，例如全局异常处理器、异常通知等。
五、日志监控与报警异常不可避免，但我们可以通过日志监控和报警来及时发现和处理异常情况。
通过监控软件运行时的日志，我们可以快速发现异常行为和错误信息。
同时，可以结合监控系统，设置报警规则，当异常情况发生时及时通知开发者或运维人员，以便进行及时的处理。
六、单元测试与自动化测试单元测试和自动化测试对于异常处理来说非常重要。
Java框架的异常处理策略在Java开发中，异常处理是一个非常重要的部分，它可以提高代码的健壮性和稳定性。
Java框架在异常处理方面采用了一系列策略，以确保代码能够在出现异常时进行正确的处理，并保证系统的正常运行。
1. 异常分类和处理Java框架中的异常可以分为两种类型：受检异常（Checked Exception）和非受检异常（Unchecked Exception）。
受检异常是指编译器要求必须进行捕获或声明抛出的异常，如IOException；非受检异常是指编译器不要求进行捕获或声明抛出的异常，如NullPointerException。
在Java框架中，针对不同类型的异常，采取了不同的处理策略。
对于受检异常，通常采用try-catch语句进行捕获和处理。
在try块中执行可能抛出受检异常的代码，通过catch块捕获异常，并根据具体情况进行相应的处理，例如记录日志、提示用户或进行回滚等。
对于非受检异常，可以使用try-catch语句进行捕获和处理，但也可以不捕获，由上层调用者在需要时进行处理，或者让异常传播到顶层统一处理。
2. 异常处理的最佳实践在Java框架中，为了提高代码的可读性和可维护性，以及避免重复的异常处理代码，通常采用以下最佳实践：2.1 使用异常处理链异常处理链是指在捕获异常后，通过将异常重新抛出，使其由上层调用者继续处理，形成一条异常处理链。
这样可以将异常的处理逻辑分散到不同的层次，提高代码的灵活性和复用性。
在Java框架中，通常使用throws关键字将异常抛给上层调用者，或者使用try-catch语句在本层进行处理后再抛出。
2.2 细化异常处理为了提高代码的可读性，可以将异常处理细化到具体的异常类型，而不是使用Exception来捕获所有异常。
通过细化异常处理，可以更加准确地定位和处理异常，同时也方便后续的异常跟踪和排查。
在Java 框架中，通常在catch块中捕获具体的异常类型，从而针对不同的异常类型进行相应的处理。
java异常处理方法及流程(一)Java异常处理方法及异常处理是Java程序设计中一个非常重要的部分。
Java提供了一系列的异常处理机制来捕获、处理和传递异常。
本文将详细介绍Java异常处理的相关流程和方法。
异常处理机制概述•异常是程序运行过程中可能发生的错误或异常情况的表示。
异常破坏了程序的正常执行流程，需要进行特殊处理来解决或恢复程序状态。
•异常处理机制包括异常抛出、异常捕获和异常传递三个阶段。
•异常抛出是指当程序运行过程中出现异常时，通过抛出异常对象来打破正常的程序流程。
•异常捕获是指使用try-catch语句块来捕获并处理异常，以便程序能够继续执行下去。
•异常传递是指在异常捕获后，将异常传递给上层调用的方法或上层调用者来处理。
异常类层次结构Java异常类层次结构是通过继承实现的，所有的异常类都是Throwable类的子类。
Throwable类有两个子类：Error和Exception。
Error是严重错误，通常不需要进行捕获和处理，而Exception是通常由程序中的错误条件引起的。
下面是Exception类的一些重要子类及其描述：•RuntimeException：运行时异常，包括NullPointerException、ArrayIndexOutOfBoundsException等。
•IOException：输入输出异常，包括FileNotFoundException、EOFException等。
•SQLException：SQL异常，用于处理数据库相关的异常。
•ClassNotFoundException：类未找到异常，用于处理类加载时找不到类的错误。
•…异常处理方法Java提供了几种异常处理方法，包括：1.try-catch语句块：用于捕获并处理异常。
try {// 可能会抛出异常的代码} catch (ExceptionType1 e1) {// 异常处理逻辑} catch (ExceptionType2 e2) {// 异常处理逻辑} finally {// 无论是否抛出异常，都会执行的代码块}–try语句块中的代码可能会抛出异常，需要进行异常捕获处理。
浅析Java异常处理机制及应用摘要：Java异常处理机制是Java编程语言中最为重要的机制之一，它可以在代码中处理各种类型的异常。
本文将对Java异常处理机制进行浅析，并从应用层面探讨一些常见的Java异常处理方法。
关键词：Java，异常处理，应用正文：一、Java异常处理机制Java异常处理机制是Java编程语言中最为重要的机制之一。
在Java语言中，异常是指一个程序运行时产生的意外情况，可以是代码中的错误，也可以是由于外部环境因素导致的错误。
Java提供了一整套异常处理机制，可以帮助开发者处理各种类型的异常。
在Java中，异常通常被定义为继承自Throwable类的任意一个子类。
常见的异常类型包括RuntimeException、IOException、ClassNotFoundException、ArithmeticException等等。
Java中异常的处理主要分为两种方式：try-catch块和throws语句。
try-catch块是一种捕捉异常的方法，其基本语法结构如下：```try {// 可能会抛出异常的代码块} catch (type1 e1) {// 处理type1类型异常的代码块} catch (type2 e2) {// 处理type2类型异常的代码块} finally {// 不管是否发生异常，都会执行的代码块}```throws语句是一种抛出异常的方法，其基本语法结构如下：```public void methodName() throws ExceptionType {// 可能会抛出异常的代码块}```二、Java异常处理的应用Java异常处理机制应用广泛，以下是应用层面探讨一些常见的Java异常处理方法。
1、基于try-catch块的异常处理try-catch块是Java中最基本的异常处理方法。
它可以在程序运行时捕捉异常，并且根据不同的异常类型采取不同的处理方法。
Java异常处理机制详解Java是一种广泛应用于软件开发的编程语言，其强大的异常处理机制为程序员提供了有效的错误处理和修复方式。
本文将详细介绍Java 异常处理机制的原理和使用方法。
一、异常的定义和分类在Java中，异常是指在程序执行过程中可能发生的错误情况。
异常可以分为两类：受检异常和非受检异常。
受检异常通常是在编译时可以预见并处理的异常，例如文件不存在、网络连接失败等；非受检异常则是在运行时可能发生的异常，如数组越界、空指针引用等。
二、异常处理的关键字和语法Java提供了一套完善的异常处理机制，主要包括以下几个关键字以及对应的语法：1. try-catch语句块：用于捕获和处理异常。
try语句块中编写可能发生异常的代码，catch语句块中编写处理异常的代码。
2. throw关键字：用于手动抛出一个异常，可以在方法中使用throw 关键字抛出指定的异常。
3. throws关键字：用于声明一个方法可能抛出的异常，方法体内部可能发生的异常由调用者负责处理。
4. finally语句块：无论是否出现异常，finally语句块中的代码都会执行。
三、try-catch语句块的使用try-catch语句块用于捕获和处理异常，其基本语法如下：```javatry {// 可能发生异常的代码} catch (ExceptionType1 exception1) {// 处理异常的代码} catch (ExceptionType2 exception2) {// 处理异常的代码} finally {// 无论是否出现异常，都会执行的代码}```在try块中编写可能发生异常的代码，catch块中编写处理异常的代码。
可以使用多个catch块来捕获不同类型的异常，从而实现对不同异常的不同处理方式。
finally块中的代码无论是否发生异常，都会被执行。
四、throw关键字的使用throw关键字用于手动抛出一个异常，其语法如下：```javathrow new ExceptionType("Exception message");```通过throw关键字，我们可以在方法中主动抛出一个指定类型的异常，并指定异常的描述信息。
Java异常及其架构分析Java异常简介Java异常是Java提供的一种识别及响应错误的一致性机制。
Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。
在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪“抛出，异常信息回答了“为什么“会抛出。
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 -- 用在方法签名中，用于声明该方法可能抛出的异常。
下面通过几个示例对这几个关键字进行简单了解。
示例一: 了解try和catch基本用法public class Demo1 {public static void main(String[] args) {try {int i = 10/0;System.out.println("i="+i);} catch (ArithmeticException e) {System.out.println("Caught Exception");System.out.println("e.getMessage(): " + e.getMessage());System.out.println("e.toString(): " + e.toString());System.out.println("e.printStackTrace():");e.printStackTrace();}}}运行结果：Caught Exceptione.getMessage(): / by zeroe.toString(): ng.ArithmeticException: / by zeroe.printStackTrace():ng.ArithmeticException: / by zeroat Demo1.main(Demo1.java:6)结果说明：在try语句块中有除数为0的操作，该操作会抛出ng.ArithmeticException 异常。
概念什么是异常?异常(exception应该是异常事件(exceptional event的缩写。
异常定义:异常是一个在程序执行期间发生的事件,它中断正在执行的程序的正常的指令流。
当在一个方法中发生错误的时候,这个方法创建一个对象,并且把它传递给运行时系统。
这个对象被叫做异常对象,它包含了有关错误的信息,这些信息包括错误的类型和在程序发生错误时的状态。
创建一个错误对象并把它传递给运行时系统被叫做抛出异常。
一个方法抛出异常后,运行时系统就会试着查找一些方法来处理它。
这些处理异常的可能的方法的集合是被整理在一起的方法列表,这些方法能够被发生错误的方法调用。
这个方法列表被叫做堆栈调用(call stack运行时系统搜寻包含能够处理异常的代码块的方法所请求的堆栈。
这个代码块叫做异常处理器,搜寻首先从发生的方法开始,然后依次按着调用方法的倒序检索调用堆栈。
当找到一个相应的处理器时,运行时系统就把异常传递给这个处理器。
一个异常处理器要适当地考滤抛出的异常对象的类型和异常处理器所处理的异常的类型是否匹配。
异常被捕获以后,异常处理器关闭。
如果运行时系统搜寻了这个方法的所有的调用堆栈,而没有找到相应的异常处理器。
怎么设计异常框架任何的异常都是Throwable类(为何不是接口??,并且在它之下包含两个字类Error / Exception,而Error仅在当在 Java虚拟机中发生动态连接失败或其它的定位失败的时候,Java虚拟机抛出一个Error对象。
典型的简易程序不捕获或抛出 Errors对象,你可能永远不会遇到需要实例化Error的应用,那就让我们关心一下ExceptionException中比较重要的就是RuntimeException-运行时异常(当然这个名字是存在争议的,因为任何的异常都只会发生在运行时,为什么说这个类时很重要的呢?因为它直接关系到你的异常框架的设计,仔细看RuntimeExceptionA method is not required to declare in its throws clause any subclasses of RuntimeException that might be thrown during the execution of the method but not caught.-可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。
Java 异常的体系结构？Java 异常体系结构是通过继承关系构建的，主要分为两大类：Throwable 类及其两个直接子类 Error 和 Exception。
1. Throwable：• Throwable 是Java 异常体系结构的根类，所有的异常都直接或间接继承自 Throwable。
• Throwable 分为两种类型：Error 和 Exception。
2. Error：• Error 表示 Java 运行时环境的内部错误或者资源耗尽错误。
•通常情况下，应用程序不需要捕获 Error，因为它们通常表示严重的问题，例如虚拟机错误或系统资源耗尽，无法通过程序处理。
3. Exception：• Exception 表示程序运行中可能出现的异常情况，它是程序员编写代码时可能会预料到并进行处理的异常。
• Exception 分为两种：受检异常（Checked Exception）和运行时异常（Unchecked Exception）。
•受检异常（Checked Exception）：•继承自 Exception，但不是 RuntimeException 的子类。
•通常是编译时发生的异常，要求程序显式地处理或抛出。
•例如 IOException、ClassNotFoundException。
•运行时异常（Unchecked Exception）：•继承自 RuntimeException。
•通常是运行时发生的异常，程序员在编写代码时不需要显式地处理或声明。
•例如NullPointerException、ArrayIndexOutOfBoundsException。
除了上述的 Throwable、Error、Exception 类及其子类外，Java 还提供了一些其他相关的类和接口，例如：• RuntimeException：•继承自 Exception，用于表示运行时异常。
•可以在编写代码时选择捕获或者不捕获。
java Java异常处理结构在Java中，任何异常对象都是ng.Throwable类或其子类的对象，即所有异常类型都是内置类Throwable的子类。
因此，Throwable类在异常类层次结构的顶层。
紧接着Throwable类把异常分成两个不同分支的子类：Exception类和Error类，如图8-1所示：图8-1 异常结构图由上图可以知道，Thorwable类是所有异常和错误的超类，两个Error和Exception子类，分别表示错误和异常。
其中，Exception异常类又分为运行时异常(RuntimeException)和非运行时异常，这两种异常有很大的区别，在于不检查异常（Unchecked Exception）和检查异常（Checked Exception）两种方式。
●Exception类用于用户程序可能出现的异常情况，也可以用来创建自定义异常类。
●Error类在通常环境下定义不希望被程序捕获的异常。
Error类型的异常用于Java运行时与运行系统本身有关的错误，如堆栈溢出属于该错误之一。
运行时异常都属于运行异常类及其子类异常，如尝试访问null对象成员（NullPointerException）、索引超出范围（IndexOutOfBoundsException）等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是运行时异常以外的异常，类型上都属于Exception类及其子类。
从程序语法角度讲是必须进行处理的异常，如果不处理，程序则无法通过编译，如输入/输出异常（IOException）、SQL语句异常（SQLException）等以及用户自定义的Exception异常。
常用的异常类如表8-1所示。
表8-1 Java常用异常类。
摘要：本文从Java异常最基本的概念、语法开始讲述了Java异常处理的基本知识，分析了Java异常体系结构，对比Spring的异常处理框架，阐述了异常处理的基本原则。
并且作者提出了自己处理一个大型应用系统异常的思想，并通过设计一个异常处理的框架来论述此思想。
摘自/XMLBeans/748871.html一、异常的概念和Java异常体系结构异常是程序运行过程中出现的错误。
本文主要讲授的是Java语言的异常处理。
Java语言的异常处理框架，是Java语言健壮性的一个重要体现。
Java把异常当作对象来处理，并定义一个基类ng.Throwable作为所有异常的超类。
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
Java异常体系结构呈树状，其层次结构图如图 1所示：Thorwable类所有异常和错误的超类，有两个子类Error和Exception，分别表示错误和异常。
其中异常类Exception又分为运行时异常(RuntimeException)和非运行时异常，这两种异常有很大的区别，也称之为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。
下面将详细讲述这些异常之间的区别与联系：1、Error与ExceptionError是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。
这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。
程序中应当尽可能去处理这些异常。
2、运行时异常和非运行时异常运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是RuntimeException以外的异常，类型上都属于Exception 类及其子类。
从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。
如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
二、异常的捕获和处理Java异常的捕获和处理是一个不容易把握的事情，如果处理不当，不但会让程序代码的可读性大大降低，而且导致系统性能低下，甚至引发一些难以发现的错误。
Java异常处理涉及到五个关键字，分别是：try、catch、finally、throw、throws。
下面将骤一介绍，通过认识这五个关键字，掌握基本异常处理知识。
1、异常处理的基本语法在java中，异常处理的完整语法是：try{//（尝试运行的）程序代码}catch(异常类型异常的变量名){//异常处理代码}finally{//异常发生，方法返回之前，总是要执行的代码}以上语法有三个代码块：try语句块，表示要尝试运行代码，try语句块中代码受异常监控，其中代码发生异常时，会抛出异常对象。
catch语句块会捕获try代码块中发生的异常并在其代码块中做异常处理，catch语句带一个Throwable类型的参数，表示可捕获异常类型。
当try中出现异常时，catch会捕获到发生的异常，并和自己的异常类型匹配，若匹配，则执行catch块中代码，并将catch块参数指向所抛的异常对象。
catch语句可以有多个，用来匹配多个中的一个异常，一旦匹配上后，就不再尝试匹配别的catch 块了。
通过异常对象可以获取异常发生时完整的JVM堆栈信息，以及异常信息和异常发生的原因等。
finally语句块是紧跟catch语句后的语句块，这个语句块总是会在方法返回前执行，而不管是否try语句块是否发生异常。
并且这个语句块总是在方法返回前执行。
目的是给程序一个补救的机会。
这样做也体现了Java语言的健壮性。
2、 try、catch、finally三个语句块应注意的问题第一、try、catch、finally三个语句块均不能单独使用，三者可以组成try...catch...finally、try...catch、try...finally三种结构，catch语句可以有一个或多个，finally语句最多一个。
第二、try、catch、finally三个代码块中变量的作用域为代码块内部，分别独立而不能相互访问。
如果要在三个块中都可以访问，则需要将变量定义到这些块的外面。
第三、多个catch块时候，只会匹配其中一个异常类并执行catch块代码，而不会再执行别的catch块，并且匹配catch语句的顺序是由上到下。
3、throw、throws关键字throw关键字是用于方法体内部，用来抛出一个Throwable类型的异常。
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。
该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。
如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
有关异常的转译会在下面说明。
throws关键字用于方法体外部的方法声明部分，用来声明方法可能会抛出某些异常。
仅当抛出了检查异常，该方法的调用者才必须处理或者重新抛出该异常。
当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣一般在catch块中打印一下堆栈信息做个勉强处理。
下面给出一个简单例子，看看如何使用这两个关键字：public static void test3() throws Exception{//抛出一个检查异常throw new Exception("方法test3中的Exception");}3、 Throwable类中的常用方法getCause()：返回抛出异常的原因。
如果 cause 不存在或未知，则返回 null。
getMessage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
三、异常处理的一般原则1、能处理就早处理，抛出不去还不能处理的就想法消化掉或者转换为RuntimeException处理。
因为对于一个应用系统来说，抛出大量异常是有问题的，应该从程序开发角度尽可能的控制异常发生的可能。
2、对于检查异常，如果不能行之有效的处理，还不如转换为RuntimeException抛出。
这样也让上层的代码有选择的余地――可处理也可不处理。
3、对于一个应用系统来说，应该有自己的一套异常处理框架，这样当异常发生时，也能得到统一的处理风格，将优雅的异常信息反馈给用户。
四、异常的转译与异常链1、异常转译的原理所谓的异常转译就是将一种异常转换另一种新的异常，也许这种新的异常更能准确表达程序发生异常。
在Java中有个概念就是异常原因，异常原因导致当前抛出异常的那个异常对象，几乎所有带异常原因的异常构造方法都使用Throwable类型做参数，这也就为异常的转译提供了直接的支持，因为任何形式的异常和错误都是Throwable 的子类。
比如将SQLException转换为另外一个新的异常DAOException，可以这么写：先自定义一个异常DAOException：public class DAOException extends RuntimeException {//(省略了部分代码)public DAOException(String message, Throwablecause) {super(message, cause);}}比如有一个SQLException类型的异常对象e，要转换为DAOException，可以这么写：DAOException daoEx = new DAOException ( "SQL异常", e);异常转译是针对所有继承Throwable超类的类而言的，从编程的语法角度讲，其子类之间都可以相互转换。
但是，从合理性和系统设计角度考虑，可将异常分为三类：Error、Exception、RuntimeException，笔者认为，合理的转译关系图应该如图 2：图 2 异常转译为什么要这么做呢？笔者认为，异常的处理存在着一套哲学思想：对于一个应用系统来说，系统所发生的任何异常或者错误对操作用户来说都是系统"运行时"异常，都是这个应用系统内部的异常。
这也是异常转译和应用系统异常框架设计的指导原则。
在系统中大量处理非检查异常的负面影响很多，最重要的一个方面就是代码可读性降低，程序编写复杂，异常处理的代码也很苍白无力。
因此，很有必要将这些检查异常Exception和错误Error转换为RuntimeException异常，让程序员根据情况来决定是否捕获和处理所发生的异常。
图中的三条线标识转换的方向，分三种情况：①：Error到Exception：将错误转换为异常，并继续抛出。
例如Spring WEB 框架中，将org.springframework.web.servlet.DispatcherServlet的doDispatch()方法中，将捕获的错误转译为一个NestedServletException异常。
这样做的目的是为了最大限度挽回因错误发生带来的负面影响。
因为一个Error 常常是很严重的错误，可能会引起系统挂起。
②：Exception到RuntimeException：将检查异常转换为RuntimeException 可以让程序代码变得更优雅，让开发人员集中经理设计更合理的程序代码，反过来也增加了系统发生异常的可能性。
③：Error到RuntimeException：目的还是一样的。
把所有的异常和错误转译为不检查异常，这样可以让代码更为简洁，还有利于对错误和异常信息的统一处理。
1、异常链异常链顾名思义就是将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出。
Java API文档中给出了一个简单的模型：try {lowLevelOp();} catch (LowLevelException le) {throw (HighLevelException)new HighLevelException().initCause(le);}当程序捕获到了一个底层异常le，在处理部分选择了继续抛出一个更高级别的新异常给此方法的调用者。
