在java中，异常处理的机制有哪几种，分别是什么
1 引子 try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。
不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。
不信
那你看看下面的代码，“猜猜”它执行后的结果会是什么
不要往后看答案、也不许执行代码看真正答案哦。
如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。
package myExample.testException; public class TestException { public 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=2 i=1 testEx2, catch exception testEx2, finally; return value=false testEx1, catch exception testEx1, finally; return value=false testEx, catch exception testEx, finally; return value=false 如果你的答案真的如上面所说，那么你错啦。
^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。
现在公布正确答案： i=2 i=1 testEx2, catch exception testEx2, finally; return value=false testEx1, finally; return value=false testEx, finally; return value=false 2 基础知识 2.1 相关概念 例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。
为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。
C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。
全程变量ErroNo常常用来反映一个异常事件的类型。
但是，这种错误处理机制会导致不少问题。
Java通过面向对象的方法来处理例外。
在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。
我们把生成例外对象并把它提交给运行时系统的过程称为抛弃(throw)一个例外。
运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获(catch)一个例外。
2.2 Throwable类及其子类 用面向对象的方法处理例外，就必须建立类的层次。
类 Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。
图1表示了例外处理的类层次。
从图中可以看出，类Throwable有两个直接子类：Error和Exception。
Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。
它有各种不同的子类分别对应于不同类型的例外。
其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException(由除0错等导致)、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。
Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。
图1 例外处理的类层次 2.3 异常处理关键字 Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。
JB的在线帮助中对这几个关键字是这样解释的： Throws: Lists the exceptions a method could throw. Throw: Transfers control of the method to the exception handler. Try： Opening exception-handling statement. Catch： Captures the exception. Finally： Runs its code before terminating the program. 2.3.1 try语句 try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
2.3.2 catch语句 catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。
例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
catch语句可以有多个，分别处理不同类的例外。
Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。
这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。
也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。
2.3.3 finally语句 try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。
通过finally语句可以指定一块代码。
无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。
通常在finally语句中可以进行资源的清除工作。
如关闭打开的文件等。
2.3.4 throws语句 throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。
对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。
如果异常的类型是Error或 RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序的正常部分中是不期待出现的。
如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。
2.3.5 throw语句 throw总是出现在函数体中，用来抛出一个异常。
程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
3 关键字及其中语句流程详解 3.1 try的嵌套 你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。
每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。
如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。
下面是一个try语句嵌套的例子。
class MultiNest { static void procedure() { try { int a = 0; int b = 42\\\/a; } catch(java.lang.ArithmeticException e) { System.out.println(in procedure, catch ArithmeticException: + e); } } public static void main(String args[]) { try { procedure(); } catch(java.lang. Exception e) { System.out.println(in main, catch Exception: + e); } } } 这个例子执行的结果为： in procedure, catch ArithmeticException: java.lang.ArithmeticException: \\\/ by zero 成员函数procedure里有自己的try\\\/catch控制，所以main不用去处理 ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throw e;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。
例如在procedure函数的catch中的System.out语句后面增加throw e;语句之后，执行结果就变为： in procedure, catch ArithmeticException: java.lang.ArithmeticException: \\\/ by zero in main, catch Exception: java.lang.ArithmeticException: \\\/ by zero 3.2 try-catch程序块的执行流程以及执行结果 相对于try-catch-finally程序块而言，try-catch的执行流程以及执行结果还是比较简单的。
首先执行的是try语句块中的语句，这时可能会有以下三种情况： 1． 如果try块中所有语句正常执行完毕，那么就不会有其他的“动做”被执行，整个try-catch程序块正常完成。
2． 如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理： ² 如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
² 如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completes abruptly）”。
3． 如果try由于其他原因R突然中止（completes abruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。
3.3 try-catch-finally程序块的执行流程以及执行结果 try-catch-finally程序块的执行流程以及执行结果比较复杂。
首先执行的是try语句块中的语句，这时可能会有以下三种情况： 1． 如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况： ² 如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
² 如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）” 2． 如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理： ² 如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果： ² 如果catch块执行正常，那么finally块将会被执行，这时分为两种情况： ² 如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。
² 如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）” ² 如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况： ² 如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throw e抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是complete abruptly的（别小看这个用得最多的return，它也是一种导致complete abruptly的原因之一啊——后文中有关于导致complete abruptly的原因分析），所以整个try-catch-finally程序块的结果是“complete abruptly”，所以在testEx1中调用testEx2时是捕捉不到testEx1中抛出的那个异常的，而只能将finally中的return结果获取到。
如果在你的代码中期望通过捕捉被调用的下级函数的异常来给定返回值，那么一定要注意你所调用的下级函数中的finally语句，它有可能会使你throw出来的异常并不能真正被上级调用函数可见的。
当然这种情况是可以避免的，以testEx2为例：如果你一定要使用finally而且又要将catch中throw的e在testEx1中被捕获到，那么你去掉testEx2中的finally中的return就可以了。
这个事情已经在OMC2.0的MIB中出现过啦：服务器的异常不能完全被反馈到客户端。
） ² 如果异常V没有catch块与之匹配，那么finally模块将被执行，分为两种情况： ² 如果finally块执行顺利，那么整个try-catch-finally程序块的结局就是“由于抛出异常V而突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，异常V将被抛弃。
3． 如果try由于其他原因R突然中止（completes abruptly），那么finally块被执行，分为两种情况： ² 如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。
² 如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completes abruptly）”，原因R将被抛弃。
3.4 try-catch-finally程序块中的return 从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。
例如，在try或者catch中return false了，而在finally中又return true，那么这种情况下不要期待你的try或者catch中的return false的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。
3.5 如何抛出异常 如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择： 第一种方式：直接在函数头中throws SomeException，函数体中不需要try\\\/catch。
比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。
boolean testEx2() throws Exception{ boolean ret = true; int b=12; int c; for (int i=2;i>=-2;i--){ c=b\\\/i; System.out.println(i=+i); } return true; } 第二种方式：使用try\\\/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。
例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常： 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); Throw e; } } 第三种方法：使用try\\\/catch\\\/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。
例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常： 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); throw new Exception(aaa); } return true; }catch (java.lang.ArithmeticException e){ System.out.println(testEx2, catch exception); ret = false; throw new Exception(aaa); }finally{ System.out.println(testEx2, finally; return value=+ret); } } 4 关于abrupt completion 前面提到了complete abruptly（暂且理解为“突然中止”或者“异常结束”吧），它主要包含了两种大的情形：abrupt completion of expressions and statements，下面就分两种情况进行解释。
4.1 Normal and Abrupt Completion of Evaluation 每一个表达式（expression）都有一种使得其包含的计算得以一步步进行的正常模式，如果每一步计算都被执行且没有异常抛出，那么就称这个表达式“正常结束（complete normally）”；如果这个表达式的计算抛出了异常，就称为“异常结束（complete abruptly）”。
异常结束通常有一个相关联的原因（associated reason），通常也就是抛出一个异常V。
与表达式、操作符相关的运行期异常有： ² A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available. ² An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero. ² A field access throws a NullPointerException if the value of the object reference expression is null. ² A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null. ² An array access throws a NullPointerException if the value of the array reference expression is null. ² An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array. ² A cast throws a ClassCastException if a cast is found to be impermissible at run time. ² An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero. ² An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array. 4.2 Normal and Abrupt Completion of Statements 正常情况我们就不多说了，在这里主要是列出了abrupt completion的几种情况： ² break, continue, and return 语句将导致控制权的转换，从而使得statements不能正常地、完整地执行。
² 某些表达式的计算也可能从java虚拟机抛出异常，这些表达式在上一小节中已经总结过了；一个显式的的throw语句也将导致异常的抛出。
抛出异常也是导致控制权的转换的原因（或者说是阻止statement正常结束的原因）。
如果上述事件发生了，那么这些statement就有可能使得其正常情况下应该都执行的语句不能完全被执行到，那么这些statement也就是被称为是complete abruptly. 导致abrupt completion的几种原因： ² A break with no label ² A break with a given label ² A continue with no label ² A continue with a given label ² A return with no value ² A return with a given value A ² throw with a given value, including exceptions thrown by the Java virtual machine 5 关于我们的编程的一点建议 弄清楚try-catch-finally的执行情况后我们才能正确使用它。
如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。
（我们需要记住：不仅throw语句是abrupt completion 的原因，return、break、continue等这些看起来很正常的语句也是导致abrupt completion的原因。
）
LTE告警问题及处理方法总结
名称告警重要程度处理办法与可能原因用户面承载链路故障告警SCTP链路故障告警配置原因：没有配置用户面承载对端路由。
硬件原因：该用户面承载所在单板硬件故障。
用户面承载链路的底层链路故障。
重要告警证书失效。
本端启用了包过滤功能导致用户面承载链路检测失败。
网络或者对端设备配置不完整导致用户面承载链路检测失和对端设备配置参数不一致。
到对端的路由不可达。
SCTP的承载链路故障。
重要告警证书失效。
网线连接错误。
对端设备故障。
SCTP链路闭塞。
SCTP链路状态异常。
X2接口配置错误。
对端基站没有配置X2接口。
重要告警本端或者对端基站没有状态正常的小区。
SCTP链路闭塞。
本端基站在对端基站黑名单中。
对端基站S1接口闭塞小区配置与设备支持规格冲突。
射频模块在共模SDR配置下,制式间载波频率间隔、功率规格、载波数规格、带宽规格等配置错误。
License资源不足。
单板不可用。
小区使用的CPRI链路故障。
重要告警小区使用的基带单元故障。
小区使用的射频单元收发通道故障。
S1信令链路故障。
时钟资源不可用（TDDLTE）。
CPRI带宽不足。
CPRIMUX规格受限。
SCTP链路状态异常。
S1接口配置错误。
跟踪区域配置信息未配置。
MME连接的基站数到达上限。
重要告警SCTP链路闭塞。
基站配置错误。
MMEC(MMECode)和其他MMEC冲突。
基站运营商配置错误此告警只可能是硬件原因：在射频单元与对端设备（上级\\\/下级射频单元或BBU）间接口链路采用
管理模块的这个错误日志是啥意思
应该怎么解决
对于一个资源受限的系统来说，通常缺少和外部通信的途径。
本例中的日志模块的目标就是要实现一个健壮和有用的日志系统。
本节从定义接口需求开始，然后探讨接口（和本地存储器）的不同方案。
至于通信方法是什么无关紧要。
在面对限制针对这些接口编程的时候，可以在其他的系统上重用我们的代码。
\ \ 注意： 将调试日志输出会严重降低处理器的性能。
如果在打开和关闭日志的时候，代码行为发生了变化，就需要考虑不同子系统的时序如何一起工作。
\ \ 具体的实现依赖于具体的系统。
有时，可以将一根输入\\\/输出线连接到发光二极管（LED)，通过摩尔斯编码将日志消息往外发送（开个玩笑）。
然而，大多数时候，需要将调试消息写到某个接口。
将系统设计成可调试的是可维护性设计的一部分。
即使代码是非常完美的，但在其他人需要增加新的特性的时候也许没有那么幸运了。
日志子系统不仅在开发阶段很有帮助，在维护阶段也是非常有用的。
\ \ 日志接口隐藏了日志的具体实现细节，也隐藏了变化（和复杂性）。
但日志需求可能在产品开发周期中发生变化。
例如，在开始阶段，开发工具可能有一个额外的串口，此时，可以将日志信息输出到计算机。
在稍后的某个阶段，串口可能不再可用，于是，就需要简化日志并把它通过一个或者两个发光二极管输出。
\ \ 有时候，我希望在系统异常的时候能够考虑得非常全面。
不幸的是，没有足够的资源输出想要的一切信息。
而且，日志输出方法可能在产品开发过程中发生变化。
这点就是应该通过将发生变化的函数调用进行封装的地方。
这里一点儿额外的开销会带来极大的灵活性。
所以，如果可以面向接口编程，那么底层实现方法的变化就没有关系。
\ \ 通常，我们想要通过一个相对狭窄的通信通道输出大量的信息。
当系统日益增大的时候，这个通道就会显得更小。
通道可以是通过RS232连接到计算机的简单的串行接口，这是一种需要特殊硬件的方法。
还可以是通过网络传送的调试数据包。
数据可以存储在外部RAM上，只有暂停处理器运行和读JTAG时才可以读取日志。
只有运行在开发环境时日志才是可用的，而在用户的硬件环境上就不可用。
日志模块的需求有三点。
\ \ 第一点，日志接口应该可以处理各种不同的实现情况。
\ 第二点，当我们正在调试系统的某一部分时，也许不希望看到来自其他部分的消息。
所以，记录日志的方法应该是特定于某个子系统。
当然，肯定需要知道其他子系统崩溃时发生的问题。
\ \ 第三点，就是关于优先级。
优先级可以让我们在调试某个子系统的细节时不至于忽略来自于其他部分的重要信息。
\ \ 日志典型调用\ 定义一个模块的主要接口需求比定义本身来说要做更多的事情，尤其在设计阶段。
但是，千言万语总可以总结成类似下面这句代码：\ \ Void Log(enum eLogSubSystem sys, enum eLogLevel level, char *msg);\ \ 这个函数原型并不是固定的，它可能随着接口的发展而变化。
但它提供了一个对于其他开发者来说非常有用的速记符号。
\ \ 日志级别可以包括：空、信息、调试、警告、错误以及危险。
子系统则取决于具体的系统，可以包括：通信、显示、系统、传感器、升级固件等。
\ \ 注意，日志消息是个字符串，与printf和iostream中的可变参数不同。
如果有这个功能，可以使用库来构造这个消息。
但是，printf和iostream系列的函数在需要更多代码空间和内存的系统中，通常是首先要去掉的。
如果情况是这样，那么我们可能需要自己去实现需要的功能，于是，这个接口应该具备满足需求的最小功能。
除了打印字符串之外，通常还需要能够每次输出至少一个数字：\ \ void LogWithNum(enum eLogSubSystem sys, enum eLogLevel level, char *msg, int number);\ \ 使用子系统标识符和优先级可以做到远程修改调试选项（如果系统允许这么做）。
在开始调试的时候，可能将所有的子系统都设置为低优先级（如调试），并且当一个子系统调试完之后，就提升其优先级（如错误）。
这样就可以只在需要的时候输出想要的信息。
因此我们需要定义一个能调整子系统和优先级灵活性的接口：\ \ void LogSetOutputLevel(enum eLogSubSystem sys, enum eLogLevel level)\ \ 因为调用代码不关心底层是如何实现的，所以调用代码不应该直接访问这个接口。
所有的日志函数都应该调用这个日志接口。
在理想情况下，底层接口不应该和任何其他模块共享，但架构图会告诉你是否正确。
日志初始化函数应该调用任何它依赖的函数，不管是初始化一个串口驱动程序还是设置输入\\\/输出线。
java 学到异常处理了
php中异常处理方法总结:当异常被触发时，通常会发生：在PHP5中添加了类似于其它语言的错误异常处理模块。
在 PHP代码中所产生的异常可被 throw语句抛出并被 catch 语句捕获。
需要进行异常处理的代码都必须放入 try 代码块内，以便捕获可能存在的异常。
每一个 try 至少要有一个与之对应的 catch。
使用多个 catch 可以捕获不同的类所产生的异常。
当 try 代码块不再抛出异常或者找不到 catch 能匹配所抛出的异常时，PHP 代码就会在跳转到最后一个 catch 的后面继续执行。
当然，PHP 允许在 catch 代码块内再次抛出（throw）异常。
当一个异常被抛出时，其后（译者注：指抛出异常时所在的代码块）的代码将不会继续执行，而 PHP 就会尝试查找第一个能与之匹配的 catch。
如果一个异常没有被捕获，而且又没用使用 set_exception_handler() 作相应的处理的话，那么 PHP 将会产生一个严重的错误，并且输出 Uncaught Exception ... （未捕获异常）的提示信息。
1、异常类的层级关系： 代码如下 复制代码 class NotFoundException extends Exception{} class InputException extends Exception{} class DBException extends Exception{} 2、配置未捕捉异常的处理器： 代码如下 复制代码 function exception_uncaught_handler(Exception $e) { header('Content-type:text\\\/html; charset=utf-8'); if ($e instanceof NotFoundException) exit($e->getMessage()); elseif ($e instanceof DBException) exit($e->getMessage()); else exit($e->getMessage()); } set_exception_handler('exception_uncaught_handler'); 3、在数据库连接代码，手动抛出DBException异常但未使用try…catch进行捕获处理，该异常将被PHP自定义异常处理器 代码如下 复制代码 exception_uncaught_handler()函数处理：$this->resConn = mysql_connect ($CONFIGS['db_host'], $CONFIGS['db_user'], $CONFIGS['db_pwd']); if (false == is_resource($this->resConn)) throw new DBException('数据库连接失败。
'.mysql_error($this->resConn)); 4、业务逻辑一瞥：if (0 != strcmp($curAlbum->interest_id, $it)) throw new NotFoundException('很抱歉，你所访问的相册不存在'); 以上就是PHP自定义异常处理器的具体使用方法实例 代码如下 复制代码 getLine().' in '.$this->getFile().': '.$this->getMessage().'<\\\/b> is not a valid E-Mail address';return $errorMsg;}}$email = someone@example.com;try { \\\/\\\/check if if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) { \\\/\\\/throw exception if email is not valid throw new customException($email); } \\\/\\\/check for example in mail address if(strpos($email, example) !== FALSE) { throw new Exception($email is an example e-mail); } }catch (customException $e) { echo $e->errorMessage(); }catch(Exception $e) { echo $e->getMessage(); }?>例子解释：上面的代码测试了两种条件，如何任何条件不成立，则抛出一个异常：1.customException() 类是作为旧的 exception 类的一个扩展来创建的。
这样它就继承了旧类的所有属性和方法。
2.创建 errorMessage() 函数。
如果 e-mail 地址不合法，则该函数返回一个错误消息。
3.执行 try 代码块，在第一个条件下，不会抛出异常。
4.由于 e-mail 含有字符串 example，第二个条件会触发异常。
5.catch 代码块会捕获异常，并显示恰当的错误消息如果没有捕获 customException，紧紧捕获了 base exception，则在那里处理异常。
重新抛出异常有时，当异常被抛出时，您也许希望以不同于标准的方式对它进行处理。
可以在一个 catch 代码块中再次抛出异常。
代码如下 复制代码 1){\\\/\\\/异常抛出条件 $msg=”数值不能大于1″;\\\/\\\/异常提示信息 throw new Exception($msg);\\\/\\\/抛出异常 } echo “数值小于1″;}\\\/\\\/在 “try” 代码块中触发异常try { num(3); echo “执行正常”;}\\\/\\\/捕获异常catch (Exception $e){ echo “错误信息：”.$e->getMessage();\\\/\\\/Exception()的系统方法获取异常信息 echo “错误文件：”.$e->getFile();\\\/\\\/Exception()的系统方法获取异常文件名 echo “行数：”.$e->getLine();\\\/\\\/Exception()的系统方法获取异常行数}\\\/\\\/======================================================================echo “
========================================================
”;\\\/\\\/扩展基本异常类function checkEmail($email){\\\/\\\/定义一个可以抛出异常的判断EMAIL合法性的函数 if (filter_var($email,FILTER_VALIDATE_EMAIL)==false){ throw new checkEmailException($email);\\\/\\\/抛出异常用EMAIL做参数 } echo “邮件合法”;}class checkEmailException extends Exception{\\\/\\\/定义扩展异常类 public function errormsg(){ $msg=”错误原因：”.$this->getMessage().”不是一个合法的EMAIL地址
”; $msg.=”错误文件名：”.$this->getFile(); $msg.=”错误行数：”.$this->getLine(); echo $msg; }}$email=”email…..@chhua.com“;try {\\\/\\\/触发异常 checkEmail($email);}\\\/\\\/捕获异常catch (checkEmailException $e){ $e->errormsg();}\\\/\\\/==================================多个异常的捕获echo “
===================================================
”;class ex1 extends Exception{\\\/\\\/定义一个异常类 public function msg(){ $msg=”错误原因：”.$this->getMessage().”大于100
”; $msg.=”错误文件：”.$this->getFile().”
”; $msg.=”错误代码：”.$this->getCode().”
”; $msg.=”行数：”.$this->getLine().”
”; echo $msg; }}class ex2 extends Exception{\\\/\\\/定义一个异常类 public function msg(){ $msg=”错误原因：”.$this->getMessage().”等于100
”; $msg.=”错误文件：”.$this->getFile().”
”; $msg.=”行数：”.$this->getLine().”
”; echo $msg; }}$num2=100;try { if ($num2>100){\\\/\\\/当条件满足时触发 throw new ex1($num2); } if ($num2==100){\\\/\\\/当条件满足时触发 throw new ex2($num2); }}catch (ex2 $e){\\\/\\\/捕获触发的异常 $e->msg();}catch (ex1 $e){\\\/\\\/捕获触发的异常 $e->msg();}\\\/* * 总结：PHP异常的使用方法分三步： * 第一步：定义异常类，如果不定义就用系统默认的异常类; * 第二步：当出现异常时用 throw 抛出异常，例如 ex1($num2);异常的参数是$num2用该异常的getMessage()获取; * 第三步：触发异常，用try子句，当满足条件时 throw new ex1($num); * 第四步：catch捕获异常 catch (ex2 $e)，相当于实例化一个定义好的异常类ex2为$e; * * 注意，异常可以定义多个，但是只能触发一个，也就是说只能用catch捕获一个异常 *\\\/?>
