即使在编译时没有错误信息产生，但在程序运行时，经常会出现一些运行时的错误，这种错误对Java而言是一种异常。有了异常就要有相应的处理方式。本章将介绍异常的基本概念以及相关的处理方式。
Java的错误类型主要有以下3种（异常属于运行时错误）：
语法错误（syntax errors）：没有遵循java语言规则。
运行错误（runtime errors）：发生一个不可以执行的操作。
逻辑错误（logic errors）：没有按照预期的方案执行。
7.1 异常的基本概念
异常也称为例外，是在程序运行过程中发生的、会打断程序正常执行的事件，下面是几种常见的异常：
1、算术异常（ArithmeticException）。
2、没有给对象开辟内存空间时会出现空指针异常（NullPointerException）。
3、找不到文件异常（FileNotFoundException）。
所以在程序设计时，必须考虑到可能发生的异常事件，并做出相应的处理。这样才能保证程序可以正常运行。
Java的异常处理机制也秉承着面向对象的基本思想。在Java中，所有的异常都是以类的类型存在，除了内置的异常类之外，Java 也可以自定义异常类。此外，Java的异常处理机制也允许自定义抛出异常。关于这些概念，将在后面介绍。
7.1.1 为何需要异常处理？
在没有异常处理的语言中，就必须使用if或switch等语句，配合所想得到的错误状况来捕捉程序里所有可能发生的错误。但为了捕捉这些错误，编写出来的程序代码经常有很多的if语句，有时候这样也未必能捕捉到所有的错误，而且这样做势必导致程序运行效率的降低。
Java的异常处理机制恰好改进了这一点。它具有易于使用、可自行定义异常类，处理抛出的异常同时又不会降低程序运行的速度等优点。因而在Java程序设计时，应充分地利用Java的异常处理机制，以增进程序的稳定性及效率。
7.1.2 简单的异常范例
Java本身已有相当好的机制来处理异常的发生。本节先来看看Java是如何处理异常的。TestException7_1是一个错误的程序，它在访问数组时，下标值已超过了数组下标所容许的最大值，因此会有异常发生：
范例：TestException7_1.java
public class TestException7_1{
public static void main(String args[]){
int arr[]=new int[5]; // 容许5个元素
arr[10]=7; // 下标值超出所容许的范围
System.out.println("end of main() method !!");
}
}
在编译的时候程序不会发生任何错误，但是在执行到第6行时，会产生下列的错误信息：Exception in thread "main" https://www.doczj.com/doc/fc13378564.html,ng.ArrayIndexOutOfBoundsException: 10
at TestException7_1.main(TestException7_1.java:6)
错误的原因在于数组的下标值超出了最大允许的范围。Java发现这个错误之后，便由系统抛出“ArrayIndexOutOfBoundsException”异常，用来表示错误的原因，并停止运行程序。如果没有编写相应的处理异常的程序代码，则Java的默认异常处理机制会先抛出异常、然后停止程序运行。
7.1.3 异常的处理
TestException7_1的异常发生后，Java便把这个异常抛了出来，可是抛出来之后没有程序代码去捕捉它，所以程序到第6行便结束，因此根本不会执行到第7行。如果加上捕捉异常的程序代码，则可针对不同的异常做妥善的处理。这种处理的方式称为异常处理。
异常处理是由try、catch与finally三个关键字所组成的程序块，其语法如下：
异常处理顺序：
1、可能出现异常的代码都应放在try代码块中。try程序块若是有异常发生时，程序的运行便中断，并抛出“异常类所产生的对象”。然后将程序控制转交给catch块。
2、抛出的对象如果属于catch()括号内欲捕获的异常类，则catch会捕捉此异常，然后进到catch块里继续运行。一个try块可以和多个catch块配合以处理多个异常。多捕获是要按照从小到大的顺序进行异常声明。
3、无论try程序块是否有异常产生，或者产生的异常是否与catch()括号里的异常相同，最后一定会运行finally块里的程序代码。finally通常用作资源的释放工作。
finally的程序代码块运行结束后，程序再回到try-catch-finally块之后继续执行。
由上述的过程可知，异常捕捉的过程中做了两个判断：第一个是try 程序块是否有异常产生，第二个是产生的异常是否和catch()括号内欲捕捉的异常相同。
值得一提的是，finally块是可以省略的。如果省略了finally块不写，则在catch()块运行结束后，程序跳到try-cath块之后继续执行。
根据这些基本概念与运行的步骤，可以绘制出如图7-1所示的流程图：
图7-1 异常处理的流程图
“异常类”指的是由程序抛出的对象所属的类，例如TestException7_1中出现的“ArrayIndexOutOfBoundsException”就是属于异常类的一种。至于有哪些异常类以及它们
之间的继承关系，稍后将会做更进一步的探讨。下面的程序代码加入了try与catch，使得程序本身具有捕捉异常与处理异常的能力。
范例：TestException7_2.java
public class TestException7_2{
public static void main(String args[]){
try{ // 检查这个程序块的代码
int arr[]=new int[5];
arr[10]=7; // 在这里会出现异常
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("数组下标越界！");
}
finally{ // 这个块的程序代码一定会执行
System.out.println("这里一定会被执行！");
}
System.out.println("main()方法结束！");
}
}
输出结果：
数组下标越界！
这里一定会被执行！
main()方法结束！
程序说明：
1、程序第7行声明一个arr的整型数组，并开辟了5个数据空间。
2、程序第8行为数组中的第10个元素赋值，此时已经超出了该数组本身的范围，所以会出现异常。发生异常之后，程序语句转到catch语句中去处理，程序通过finally代码块统一结束。
上面程序的第5~9行的try 块是用来检查是否会有异常发生。若有异常发生，且抛出的异常是属于ArrayIndexOutOfBoundsException类，则会运行第10~13行的代码块。因为第8行所抛出的异常正是ArrayIndexOutOfBoundsException类，因此第12行会输出“数组下标越界！”字符串。由本例可看出，通过异常的机制，即使程序运行时发生问题，只要能捕捉到异常，程序便能顺利地运行到最后，且还能适时的加入对错误信息的提示。
程序TestException7_2里的第10行，如果程序捕捉到了异常，则在catch括号内的异常类ArrayIndexOutOfBoundsException之后生成一个对象e，利用此对象可以得到异常的相关信息，下例说明了类对象e的应用：
范例：TestException7_3.java
public class TestException7_3{
public static void main(String args[]){
try{
int arr[]=new int[5];
arr[10]=7;
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("数组下标越界！");
System.out.println("异常："+e); // 显示异常对象e的内容
}
System.out.println("main()方法结束！");
}
}
输出结果：
数组下标越界！
异常：https://www.doczj.com/doc/fc13378564.html,ng.ArrayIndexOutOfBoundsException: 10
main()方法结束！
例子中省略了finally块，但程序依然可以运行。在第10行中，把catch()括号内的内容想象成是方法的参数，而e就是ArrayIndexOutOfBoundsException类的对象。对象e接收到由异常类所产生的对象之后，就进到第11行，输出“数组下标越界！”字符串，而第12行则是输出异常所属的种类，也就是https://www.doczj.com/doc/fc13378564.html,ng.ArrayIndexOutOfBoundsException。而https://www.doczj.com/doc/fc13378564.html,ng 正是ArrayIndexOutOfBoundsException类所属的包。
由前面的知识，我们知道，直接打印对象可以输出内容，说明该类重写了toString()方法。所以，前面我们直接打印e，其实就是e.toString()。
System.out.println(e); System.out.println(e.toString());
除了可以直接打印异常类对象之外，还可以利用如下函数访问异常信息：
getMessage()：返回该异常的详细描述字符串。
printStackTrace()：将该异常的跟踪栈信息输出到标准错误输出。
printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。
getStackTrace()：返回该异常的跟踪栈信息。
各函数使用方法如下：
System.out.println(e.getMessage()); e.printStackTrace();
e.printStackTrace(System.out); System.out.println(e.getStackTrace());
7.1.4 异常处理机制的回顾
当异常发生时，通常可以用两种方法来处理，一种是交由Java默认的异常处理机制做处理。但这种处理方式，Java通常只能输出异常信息，接着便终止程序的运行。如TestException7_1的异常发生后，Java默认的异常处理机制会显示出：
Exception in thread "main" https://www.doczj.com/doc/fc13378564.html,ng.ArrayIndexOutOfBoundsException: 10
at TestException7_1.main(TestException7_1.java:6)
接着结束TestException7_1的运行。
另一种是处理方式是自行编写的try-catch-finally块来捕捉异常，如TestException7_2与TestException7_3。自行编写程序代码来捕捉异常最大的好处是：可以灵活操控程序的流程，且可做出最适当的处理。图7-2绘出了异常处理机制的选择流程。
图7-2 异常处理的方法
7.2 异常类的继承架构
异常可分为两大类：https://www.doczj.com/doc/fc13378564.html,ng.Exception类与https://www.doczj.com/doc/fc13378564.html,ng.Error类。这两个类均继承自https://www.doczj.com/doc/fc13378564.html,ng.Throwable类。图7-3为Throwable类的继承关系图。
图7-3 Throwable类的继承关系图
习惯上将Error与Exception类统称为异常类，但这两者本质上还是有不同的。Error类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如JA V A虚拟机出错或栈溢出错误或内存泄漏错误等就属于Error。
不同于Error类，Exception类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如TestException7_2里所捕捉到的ArrayIndexOutOfBoundsException就是属于这种异常。
从异常类的继承架构图中可以看出：Exception类扩展出多个子类，其中IOException、RuntimeException是较常用的两种。RuntimeException即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。与RuntimeException不同的是，IOException一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。
几种常见的RuntimeExcpetion如下：
ArrayIndexoutofBoundsException：数组下标越界异常。
ArithmeticException：算术异常。如整数被0除，运算得出的结果。
NullPointerException：空指针异常。当对象没被实例化时，访问对象的属性或方法。
当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与catch语句中的类的类型进行匹配，然后在相应的catch中进行处理。
7.3 抛出异常
前两节介绍了try_catch_finally程序块的编写方法，本节将介绍如何抛出（throw）异常，以及如何由try-catch来接收所抛出的异常。抛出异常有下列两种方式：
1、程序中抛出异常
2、指定方法抛出异常
以下两小节将介绍如何在程序中抛出异常以及如何指定方法抛出异常。
7.3.1 在程序中抛出异常
当程序出现错误时，系统会自动抛出异常，除此之外，java也允许程序自行抛出异常，
自行抛出异常使用throw语句完成。其语法格式如下：
throw 异常类实例对象;
可以发现在throw后面抛出的是一个异常类的实例对象，下面来看一个实例：
范例：TestException7_4.java
public class TestException7_4{
public static void main(String args[]){
int a=4, b=0;
try{
if(b==0)
throw new ArithmeticException("一个算术异常"); // 抛出异常
else
System.out.println(a+"/"+b+"="+a/b); // 若抛出异常，则执行此行}
catch(ArithmeticException e){
System.out.println("抛出异常为："+e);
}
}
}
输出结果：
抛出异常为：https://www.doczj.com/doc/fc13378564.html,ng.ArithmeticException: 一个算术异常
程序说明：
1、程序TestException7_4是要计算a/b的值。因b是除数，不能为0。若b为0，则系统会抛出ArithmeticException异常，代表除到0这个数。
2、在try块里，利用第8行来判断除数b是否为0。如果b=0，则运行第9行的throw 语句，抛出ArithmeticException异常。如果b不为0，则输出a/b的值。在此例中强制把b 设为0，因此try块的第9行会抛出异常，并由第13行的catch()捕捉到异常。
3、抛出异常时，throw关键字所抛出的是异常类的实例对象，因此第9行的throw语句必须使用new关键字来产生对象。
7.3.2 指定方法抛出异常
如果方法内的程序代码可能会发生异常，且方法内又没有使用任何的代码块来捕捉这些异常时，则必须在声明方法时一并指明所有可能发生的异常，以便让调用此方法的程序得以做好准备来捕捉异常。也就是说，如果方法会抛出异常，则可将处理此异常的try-catch-finally 块写在调用此方法的程序代码内。
如果要由方法抛出异常，则方法必须以下面的语法来声明：
方法名称（参数…）throws 异常类1，异常类2，…
范例TestException7_5是指定由方法来抛出异常的，如下所示：
范例：TestException7_5.java
public class TestException7_5{
public static void main(String[] args){
System.out.println("商为:" + div(10, 0));
}
public static int div(int a, int b) throws Exception{
return a / b;
}
}
编译结果：
TestExeption7_5.java:7: 未报告的异常https://www.doczj.com/doc/fc13378564.html,ng.Exception；必须对其进行捕捉或声明以便抛出
System.out.println("商为:" + div(a, b));
^
1 error
程序说明：
如果在方法中用throws抛出一个Exception异常，则在调用它的地方就必须明确地用try-catch来捕捉，否则会编译报错。
解决办法：
在TestExeption7_5程序之中，如果在调用div函数的时候加上try-catch的语句对其进行捕捉可以解决。如下
public class TestException7_6{
public static void main(String[] args){
try{
System.out.println("商为:" + div(10, 0));
}
catch (Exception e){
System.out.println(e);
}
}
public static int div(int a, int b) throws Exception {
return a / b;
}
}
也可以将throws Exception换成throws ArithmeticException。
如果在main()方法后再用throws Exception声明的话，那么程序也是依然可以编译通过的。也就是说在调用用throws抛出异常的方法时，可以将此异常在方法中再向上传递，而main()方法是整个程序的起点，所以如果在main()方法处如果再用throws抛出异常，则此异常就将交由JVM进行处理了。
7.4 编写自己的异常类
在JDK中提供的大量API方法之中含有大量的异常类，但这些类在实际开发中往往并不能完全的满足设计者对程序异常处理的需要，在这个时候就需要用户自己去定义所需的异常类了，用一个类清楚的写出所需要处理的异常。为了处理各种异常，Java可通过继承的方式编写自己的异常类。因为所有可处理的异常类均继承自Exception类，所以自定义异常类也必须继承这个类。
自己编写异常类的语法如下：
class 异常名称extends Exception
{
…
}
Exception构造方法：public Exception(String message);
通常在自定义异常类的构造方法中调用父类Exception的构造方法：super("message");如有必要，还需要覆盖下列获得错误信息的方法：toString()、getMessage()、printStackTrace() 我们可以在自定义异常类里编写方法来处理相关的事件，甚至可以不编写任何语句也可正常地工作，这是因为父类Exception已提供相当丰富的方法，通过继承，子类均可使用它们。
接下来以一个范例来说明如何定义自己的异常类以及如何使用它们。
范例：TestException7_6.java
class DefaultException extends Exception{
public DefaultException(String message) {
super(message); // 调用Exception类的构造方法，存入异常信息}
public String toString(){
return "自定义异常类的toString方法";
}
public String getMessage(){
return "自定义异常类的getMessage方法";
}
public void printStackTrace() {
System.out.println("自定义异常类的printStackTrace方法");
}
}
public class TestException7_6{
public static void main(String args[]){
try{
double money = 8668.6d;
if (money < Math.pow(2, 20)) {
// 在这里用throw直接抛出一个DefaultException类的实例对象
throw new DefaultException("金额不足");
}
}
catch(DefaultException e){
System.out.println(e); // 显示异常对象e的内容
System.out.println(e.toString());
System.out.println(e.getMessage());
e.printStackTrace();
}
System.out.println("main()方法结束！");
}
}
7.5 多态中异常的声明抛出原则
在多态中，异常的声明抛出有一定的原则：
子类覆盖父类方法，子类抛出的异常必须为父类可视异常。即子类抛出的异常不能多于父类抛出的异常。例如：
class OneException extends Exception {
}
class TwoException extends Exception {
}
class ThreeException extends Exception {
}
class Father {
void show() throws OneException, TwoException {
}
}
public class Test extends Father {
// 所抛出的异常不能多于父类抛出的异常
void show() throws TwoException, ThreeException {
}
public static void main(String[] args) {
new Test().show();
}
}
子类实现接口，如接口定义的方法抛出的异常不存在交集，在子类实现中，不能声明抛出任何异常。例如：
class OneException extends Exception {
}
class TwoException extends Exception {
}
interface Football {
void play() throws OneException;
}
interface Basketball {
void play() throws TwoException;
}
public class Test implements Football, Basketball {
// 接口不存在交集，不能声明抛出的异常
public void play() {
}
public static void main(String[] args) {
new Test().play();
}
}
7.6 异常使用规则
如果在方法内处理了异常则不需要抛出，如果需要调用者处理异常则需要使用throws 抛出异常。如果多个类发生了共同异常可以考虑设计异常类。一般能用简单逻辑判断的不要
使用异常，直接用if…else结构判断即可。不要过度使用异常、不要使用过于庞大的try块、不要忽略捕捉到的异常。
7.7 断言
断言是Java 1.4版新增的一个特性，并在该版本中增加了一个关键字assert。可以把断言功能看成是异常处理的高级形式。
所谓断言(Assertion)是一个Java语句，布尔表达式，程序员认为在程序执行时该表达式的值应该为true。系统通过计算该布尔表达式执行断言，若该表达式为false系统会报告一个错误。通过验证断言是true，能够使程序员确信程序。
为了提高性能，可能要关闭断言检查。通常在程序开发和调试阶段开启断言功能，在部署时关闭。
5.0以前的JDK缺省情况下，若使用assert作为标识符，编译器会给出警告(不是编译错误)，从5.0以后将是一个错误。
使用断言：
·断言失败是致命的、不可恢复的错误。
·断言检查仅仅用在程序开发和测试阶段。
语法如下：
1、assert boolean条件
或者
2、assert boolean条件: 详细信息
这两个形式都会对“条件”进行判断，“条件”是一个布尔表达式。如果判断结果为假（false）则抛出AssertionError。在第二种形式中，“详细信息”会传进AssertionError的构造函数中并转成一个消息字符串。
例如，如果要进行如下的计算时：double y = Math.sqrt(x);
sqrt(x)是一个开平方运算，x必须为正才不会出错。为了检查传入的参数是否为正，可以使用如下的断言语句：
assert x >= 0;
double y = Math.sqrt(x);
或者
assert x >= 0 : "x >= 0";
double y=Math.sqrt(x);
当x为负值时，assert语句将抛出AssertionError异常，你就可以根据异常信息对程序的其它部分进行检查。
打开和关闭断言功能：
默认情况下，断言是关闭的。可以通过-enableassertions或者-ea选项来运行程序以打开断言：
java -ea Myapp
打开或者关闭断言是类装载器的功能。当断言功能被关闭时，类装载器会跳过那些和断言相关的代码，因此不会降低程序运行速度，即它们没有任何副作用。
可以使用-da选项来关闭断言功能：
java -da Myapp
·本章摘要：
1、程序中没有处理异常代码时，Java的默认异常处理机制会做下面的操作：
（1）、抛出异常。
（2）、停止程序运行。
2、异常处理是由try、catch与finally三个关键字所组成的程序块。
3、try程序块中若有异常发生时，程序的运行便会中断，抛出“由系统类所产生的对象”，并依下列的步骤来运行：
（1）、抛出的对象如果属于catch()括号内所要捕捉的异常类，catch会捕捉此异常，然后进到catch程序块里继续执行。
（2）、无论try程序块是否捕捉到异常，也不管捕捉到的异常是否与catch()括号里的异常相同，最后都会运行finally块里的程序代码。
（3）、finally中的代码是异常的统一出口，无论是否发生异常都会执行此段代码。
4、当异常发生时，有两种处理方式：
（1）、交由Java默认的异常处理机制去处理。
（2）、自行编写try-catch-finally块来捕捉异常。
5、异常可分为两大类：https://www.doczj.com/doc/fc13378564.html,ng.Exception与https://www.doczj.com/doc/fc13378564.html,ng.Error类。
6、RuntimeException可以不编写异常处理的程序代码，依然可以编译成功，它是在程序运行时才有可能发生的；而其它的Exception一定要编写异常处理的程序代码才能使程序通过编译。
7、catch()括号内，只接收由Throwable类的子类所产生的对象，其它的类均不接收。
8、抛出异常有下列两种方式：
（1）、在程序中抛出异常。
（2）、指定方法抛出异常。
9、程序中抛出异常时，要用到throw这个关键字。
10、如果方法会抛出异常（使用throws），则可将处理此异常的try-catch-finally块写在调用此方法的程序代码中。
得到一个异常对象是，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型异常的方法后，运行时系统把当前异常交给这个方法处理；如果找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。捕获异常是通过try-catch-finally语句实现的。语法为：try{ ... }catch(ExceptionName1 e){ ... }catch(ExceptionName2 e){ ... } ... }finally{ ... } 2)声明抛弃异常：当Java 程序运行时系统得到一个异常对象时，如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，声明抛弃异常。声明抛弃异常是在一个方法声明中的throws子句中指明的。如：public int read() throws IOException{ ... } 其中throws IOException就是声明抛弃异常，throws后可以跟多个异常类型。 1. https://www.doczj.com/doc/fc13378564.html,ng.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. https://www.doczj.com/doc/fc13378564.html,ng.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. https://www.doczj.com/doc/fc13378564.html,ng.arithmeticexception 这个异常的 好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. 是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. https://www.doczj.com/doc/fc13378564.html,ng.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. https://www.doczj.com/doc/fc13378564.html,ng.illegalaccessexception 这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException 违背安全原则异常：SecturityException 文件已结束异常：EOFException 文件未找到异常：FileNotFoundException 字符串转换为数字异常：NumberFormatException 操作数据库异常：SQLException 输入输出异常：IOException 方法未找到异常：NoSuchMethodException https://www.doczj.com/doc/fc13378564.html,ng.AbstractMethodError 抽象方法错误。当应用试图调用抽象方法时抛出。https://www.doczj.com/doc/fc13378564.html,ng.AssertionError 断言错。用来指示一个断言失败的情况。https://www.doczj.com/doc/fc13378564.html,ng.ClassCircularityError 类循环依赖错误。在初始化一个类时， 个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。https://www.doczj.com/doc/fc13378564.html,ng.Error 错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。https://www.doczj.com/doc/fc13378564.html,ng.ExceptionInInitializerError 初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异
#include "stdafx.h" #include #include #include // 内存泄露检测机制 #define _CRTDBG_MAP_ALLOC #ifdef _DEBUG #define new new(_NORMAL_BLOCK, __FILE__, __LINE__ #endif // 自定义异常类 class MyExcepction { public: // 构造函数,参数为错误代码 MyExcepction(int errorId { // 输出构造函数被调用信息 std::cout << "MyExcepction is called" << std::endl; m_errorId = errorId; } // 拷贝构造函数 MyExcepction( MyExcepction& myExp { // 输出拷贝构造函数被调用信息 std::cout << "copy construct is called" << std::endl; this->m_errorId = myExp.m_errorId; }
~MyExcepction( { // 输出析构函数被调用信息 std::cout << "~MyExcepction is called" << std::endl; } // 获取错误码 int getErrorId( { return m_errorId; } private: // 错误码 int m_errorId; }; int main(int argc, char* argv[] { // 内存泄露检测机制 _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ; // 可以改变错误码,以便抛出不同的异常进行测试 int throwErrorCode = 110; std::cout << " input test code :" << std::endl; std::cin >> throwErrorCode; try { if ( throwErrorCode == 110 { MyExcepction myStru(110;
App9_1.java：输出一个数组的所有元素，捕获数组下标越界异常和除娄为0异常。public class App9_1{ public static void main(String args[]){ int i; int[] a={1,2,3,4}; for(i=0;i<5;i++) System.out.println(" a["+i+"]="+a[i]); System.out.println("5/0"+(5/0)); } } App9_2.java：使用try-catch-finall语句对程序中的异常进行捕获与处理。 public class App9_2{ public static void main(String args[]){ int i; int a[]={1,2,3,4}; for (i=0;i<5;i++){ try{ System.out.print("a["+i+"]/"+i+"="+(a[i]/i)); } catch(ArrayIndexOutOfBoundsException e){ System.out.print("捕获到了数组下标越界异常"); } catch(ArithmeticException e){ System.out.print("异常类名称是："+e); //显示异常信息 } catch(Exception e){ System.out.println("捕获"+e.getMessage()+"异常！"); //显示异常信息 } finally{ System.out.println(" finally i="+i); } } System.out.println("继续！！"); } } App9_3.java：使用throw语句在方法中抛出异常。 public class App9_3{ public static void main(String args[]){ int a=5,b=0; try{ if (b==0) throw new ArithmeticException(); //抛出异常，不是必须的 else System.out.println(a+"/"+b+"="+a/b); //若不抛出异常，则运行此行
异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C开始，你也许已经知道如何用if...else...来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java语言设计者的高明之处，也是Java语言中的一个难点，下面是我对Java异常知识的一个总结，也算是资源回收一下。 一、Java异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.doczj.com/doc/fc13378564.html,ng.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出https://www.doczj.com/doc/fc13378564.html,ng.ArithmeticException的异常。 有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。 天有不测风云，人有旦夕祸福，Java的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是Throwable的一种形式，它指出了合理的应用程序想要捕获的条件。 异常的对象从哪里来呢？有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。 异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行，一般结构如下： try{ 程序代码 }catch(异常类型1 异常的变量名1){ 程序代码 }catch(异常类型2 异常的变量名2){ 程序代码 }finally{ 程序代码 } catch语句可以有多个，用来匹配多个异常，匹配上多个中一个后，执行catch语句块时候仅仅执行匹配上的异常。catch的类型是Java语言中定义的或者程序员自己定义的，表示代
Java语言中的异常处理机制 导语：为了加强程序的健壮性、流畅性、稳定性，就需要考虑有可能发生的异常，并进行相应的处理。下面就由为大家介绍一下Java语言中的异常处理机制，欢迎大家阅读! 1概述 在应用程序运行的过程中，经常会出现这样一些现象：用户不按照要求输入、需要进行处理的文件丢失、分母为零、数组下标超出预定范围、网络中断等，我们把这种现象称为异常。由于异常情况总是难免的，所以一个好的应用程序不仅要满足用户的基本需求，还要具备处理有可能出现的异常情况的能力，即程序必须具备较强的容错能力，把这种对异常进行处理的机制称为异常处理。对异常处理有两种常见方法：计算机系统遇到错误，给出出错信息并结束正在运行的程序;由程序员在程序中加入异常处理的功能。早期的程序设计语言没有提供专门进行异常处理的功能，程序员在编写程序的过程中，进行处理异常的代码往往和正常的代码混杂在一起，导致程序的可维护性和可读性下降。Java语言采取了异常处理机制，其方式为“抛出-捕获”，一个异常一旦产生，Java语言采取相应的机制来处理它，避免出现死循环、死机以及其他更大的危害，尽可能预防错误代码带来的不可预期的后果，整个程序的安全性得到了极大的提高。 2Java语言中的异常概述 Java语言提供了功能强大的异常处理机制，将所有处理异常的代码集中放置，以保证正常功能代码和处理异常的代码分开。在Java
程序设计语言中，采用了大量的异常类来进行处理，这些异常类可分为两大类：https://www.doczj.com/doc/fc13378564.html,ng.Exception和https://www.doczj.com/doc/fc13378564.html,ng.Error。Exception 类解决由程序本身及环境所产生的异常。而Error类则处理较少发生的内部系统错误。Exception类异常可以捕获并进行相应处理，而Error类异常，则是由用户按照系统提示关闭程序。常见的异常类如下表所示： 在以上常见的Java异常类中，每个异常类反映一类异常错误，其中包含了异常错误信息和处理方法。当程序运行过程中，出现一种异常现象，产生一个相应的异常类对象，再由相应的异常类进行处理，从而避免对系统产生更大的危害，以保证程序的正常运行。 3常见的异常处理方法 常见的异常处理方法有两种：一种处理异常是在产生异常的方法中，使用try…catch…finally结构;还有一种是进行异常的移交，使用关键字throws和throw交给上层方法去处理异常。 在该案例中，对三种异常进行了捕获，分别是数组下标越界、输入数据格式不正确和Exception异常，当触发某种异常，则对相应的异常异常进行处理。Exception异常类是所有异常的基类，当出现catch块没有进行捕获的异常，则采用Exception异常类进行异常处理。 异常的移交： 实例分析：初始化参数x使用了-2，将触发NegativeArraySizeException异常，但在Sum方法中不对该异常进
异常处理练习题 一、选择题 1.java中用来抛出异常的关键字是 (C) A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是(A) A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都丌对 3.（A）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 4.java语言中，下列哪一子句是异常处理的出口(C) A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都丌对 5.下列程序的执行，说法错误的是 (C) public class MultiCatch { public static void main(String args[]) { try { int a=args.length; int b=42/a; int c[]={1}; c[42]=99; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42”
D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是（D） class ExMulti { static void procedure() { try { int c[]={1}; c[42]=99; } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越界限异常：”+e); } } public static void main(String args[]) { try { procedure(); int a=args.length; int b=42/a; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } } } A、程序只输出第12行的异常信息 B、程序只输出第26行的异常信息 C、程序将不输出异常信息 D、程序将输出第12行和第26行的异常信息 7.下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。class TrowsDemo { static void procedure() throws IllegalAccessExcepton { System.out.println(“inside procedure”); throw__new_____IllegalAccessException(“demo”);
异常的基本概念 异常是导致程序终止运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断执行，造成不必要的损失。 在没有异常处理的语言中如果要回避异常，就必须使用大量的判断语句，配合所想到的错误状况来捕捉程序中所有可能发生的错误。 Java异常处理机制具有易于使用、可自行定义异常类、处理抛出的异常同时又不会降低程序运行的速度等优点。因而在java程序设计时应充分地利用java的异常处理机制，以增进程序的稳定性及效率。 当程序中加入了异常处理代码，所以当有异常发生后，整个程序并不会因为异常的产生而中断执行。而是在catch中处理完毕之后，程序正常的结束。 在整个java异常的结构中，实际上有两个最常用的类，分别为Exception和Error 这两个类全都是Throwable的子类。 Exception:一般表示的是程序中出现的问题，可以直接使用try……catch处理。 Error：一般值JVM错误，程序中无法处理。 Java异常处理机制。 在整个java的异常处理中，实际上也是按照面向对象的方式进行处理，处理的步骤如下： 1）一旦产生异常，则首先会产生一个异常类的实例化对象。 2）在try语句中对此异常对象进行捕捉。 3）产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功则执行catch语句中的代码。 异常处理 在定义一个方法时可以使用throws关键字声明，表示此方法不处理异常，而交给方法的调用处进行处理，在方法调用处不管是否有问题，都要使用try……catch块进行异常的捕获与处理。 如果在主方法中使用throws关键字，则程序出现问题后肯定交由jvm处理，将导致程序中断。 与throws关键字不同的是，throw关键字人为的抛出一个异常，抛出时直接抛出异常类的实例化对象即可。 Exception在程序中必须使用try……catch进行处理。RuntimeException可以不使用try……catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。（建议RuntimeException的子类也使用try……catch进行处理，否则产生的异常交给jvm处理会导致程序中断。） 继承关系： Exception》RuntimeException》lllegalArgumentException》NumberFormatException; 异常类必须继承于Exception 建议：继承Exception一般要添加全部父类型一样的构造器！ class NameOrPwdException extends Exception { public NameOrPwdException() {
第13章异常课堂练习（2理论+2习题课+2上机） 【教学目标】 ?了解异常和异常处理的概貌（第13.2节）。 ?探究使用异常处理的优点（第13.3节）。 ?区别异常的类型：Error (致命的) 和Exception (非致命的), 以及必检和免检异常（第13.4节）。 ?在方法头中声明异常（第13.5.1节）。 ?在方法中抛出异常（第13.5.2节）。 ?编写try-catch 块处理异常（第13.5.3节）。 ?解释异常是如何传播的（第13.5.3节）。 ?在try-catch块中使用finally子句（第13.6节）。 ?只为非预期错误使用异常（第13.7节）。 ?在catch 块中重新抛出异常（第13.8节）。 ?创建链式异常（第13.9节）。 ?定义自定制的异常类（第13.10节）。 【教学重点】 ?了解异常的处理机制 ?异常的解决方法 ?Exception类的作用及其使用方法 ?必检异常、免检异常的特点 【基本知识点】 1、常见异常演示 （1）算数异常：https://www.doczj.com/doc/fc13378564.html,ng.ArithmeticException 在算术运算中，0作为除数时，系统将产生该异常，示例： public static void main(String[] args) { int x=10; int y=0; int m=x/y; } Exception in thread "main" https://www.doczj.com/doc/fc13378564.html,ng.ArithmeticException: / by zero at exception.NotChecketException.main(NotChecketException.java:7)（2）数组越界异常：https://www.doczj.com/doc/fc13378564.html,ng.ArrayInd exOutOfBoundsException 在数组下标越界时，将产生该异常，示例：
提交方式： 把文件名改为学号姓名，提交文档和源码(只需提交最顶层包文件夹） 实验六异常处理 一、实验目的 1.学会利用Try-catch-finally语句来捕获和处理异常； 2.掌握自定义异常类的方法。 二、实验要求 1.通过编程理解系统异常处理的机制和创建自定义异常的方法。 2.掌握基础类。 三、实验内容 （一）异常处理机制 1. 编写使用try…catch 语句处理异常的程序文件Demo4_1.java，
编译并运行程序，并把运行结果复制在下面 。 注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception是ArithmeticException的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。 2、源文件是Demo3_2.java。要捕捉的异常是除数为零和数组下标越界。通过修改a和c[]下标值体验程序。 【思考】 ①先运行上面程序，观察运行结果。 ②按下条件分别修改数据，编译后运行，观察输出结果，分析在try…catch块里那些语句没有被执行，为什么? 块外那些语句可被执行到，为什么? 修改a=0，保持c[2]=200； 保持a=10，修改c[3]=200， 修改a=0，修改c[3]=200； ③再添加一个catch{Exception e}{ },位置在最前面，观察编译信息，说明什么？ 3、编写Demo3_3.java 程序，计算两数相除并输出结果。使用两个catch子句，分别捕捉除数为0的异常和参数输入有误异常。源代码如下：
如何使用异常处理机制 《PHP核心技术与最佳实践》第1章面向对象思想的核心概念，本章将就面向对象一些概念展开讨论，其中重点讨论PHP特色的面向对象的风格和语法，并通过相互借鉴和对比，使读者认识PHP自身的特点，尤其是和其他语言中不同的地方。本节为大家介绍如何使用异常处理机制。 1.6.1 如何使用异常处理机制（1） 异常的思想最早可以追溯到20世纪60年代，其在C++、Java中发扬光大，PHP则部分借鉴了这两种语言的异常处理机制。 PHP里的异常，是程序运行中不符合预期的情况及与正常流程不同的状况。一种不正常的情况，就是按照正常逻辑不该出错，但仍然出错的情况，这属于逻辑和业务流程的一种中断，而不是语法错误。PHP里的错误则属于自身问题，是一种非法语法或者环境问题导致的、让编译器无法通过检查甚至无法运行的情况。 在各种语言里，异常（exception）和错误（error）的概念是不一样的。在PHP里，遇到任何自身错误都会触发一个错误，而不是抛出异常（对于一些情况，会同时抛出异常和错误）。PHP一旦遇到非正常代码，通常都会触发错误，而不是抛出异常。在这个意义上，如果想使用异常处理不可预料的问题，是办不到的。比如，想在文件不存在且数据库连接打不开时触发异常，是不可行的。这在PHP里把它作为错误抛出，而不会作为异常自动捕获。 以经典的除零问题为例，如代码清单1-16所示。 代码清单1-16 exception.php 1.// exception.php 2.getMessage(); 9.$a=-1; 10.}
非惩罚性护理不良事件报告制度及激励机制 一、不良事件的定义 是指在护理过程中发生的、不在计划内的跌倒、坠床、压疮、用药错误、走失、误吸或窒息、烫伤及其他与患者安全相关的非正常的护理意外事件。 二、不良事件报告的意义 通过报告不良事件，及时发现潜在的不安全因素，可有效避免护理差错与纠纷的发生，保障病人安全，不良事件的全面报告，有利于发现医院安全系统存在的不足，提高医院系统安全水平，促进医院及时发现安全事故隐患，不断提高对错误的识别能力，不良事件报告后的信息共存，可以使相关人员从他人的过失中吸取经验教训，以免重蹈覆辙。 三、护理不良事件的范围 1、患者在住院期间发生压疮、坠床、跌倒、导管滑脱、用药失误、走失、误吸或窒息、烫伤及其他与患者安全相关的护理意外。 2、因护理操作失误导致患者出现严重并发症、住院时间延长或住院费用增加等。 3、严重药物不良反应或输血不良反应。 4、严重院内感染。 四、不良事件报告原则 非惩罚性、主动性报告的原则：护理部鼓励护理人员主动、自愿报告不良事件，包括本人的或本科室的，也可报告其他人或其他科室的，可以实名报告，也可匿名报告，对主动报告的科室和个人的有关信息，护理部将严格保密。 五、上报内容 包括患者一般资料，不良事件发生的时间地点、不良事件项目分类、发生的主要原因、采取的措施、患者损害的严重程度及后果和改进措施。上报形式以个人或科室为上报单位。 六、上报形式 1、口头报告：发生严重不良事件时，护理人员应立即向护士长、科主任、总值班、护理部口头报告事件情况。 2、书面报告：护理人员书面填写《护理不良事件报告单》。 3、网络报告：护理人员登录内网，填写《护理不良事件报告单》电子表格，
Java异常处理作业 孙月巧 1、参考下面的程序，试修改程序，捕获相关异常，使得程序能正常运行。【提示：用错误数据测试，即可得到异常类名，运行时主方法参数输入abc 测试】 package November; import java.util.Scanner; public class StringIndexOutOf{ public static void main(String args[]){ System.out.println("请输入一个字符串："); try{ Scanner reader=new Scanner(System.in); String str = reader.nextLine(); System.out.println("第四个字符为 " + str.charAt(3)); int aa = Integer.parseInt(str); System.out.println("平方为 " + aa * aa); } catch(StringIndexOutOfBoundsException e){ System.out.println("您输入的数值下标越界"); } catch(NumberFormatException nfe){ System.out.println("您输入的不是数字"); } } } 2、从命令行得到5个整数，放入一整型数组，然后打印输出，要求：如果输入数据不为整数，要捕获Integer.parseInt()产生的异常，显示“请输入整数”，捕获输入参数不足5个的异常(数组越界)，显示“请输入至少5个整数”。 package November; public class Test2 { public static void main(String[] args) { System.out.println("请输入五个整数："); try {
第6章异常处理机制 一、选择题 1．下列关于异常的说法正确的是（B）。 A．异常是编译时的错误 B．异常是运行时出现的错误 C．异常就是程序错误，程序错误就是异常 D．以上都不对 2．下列哪个类是异常类的父类（根类）（A）。 A．Exception B．ArithmeticException C．NullPointerException D．ArrayIndexOutofBoundException 3．有关下列异常处理机制叙述正确的是（C）。 try{ 可能产生异常的语句块; }catch(exceptiontype1 e){ 处理异常e的语句块; }catch(exceptiontype2 e){ 处理异常e的语句块; } …… finally{ 最终处理语句块; } A．try子句可能有多个，catch子句可能有多个，finally子句必须有。 B．多个catch参数中的异常类可以有父子关系，但父类异常的catch子句应该在子类异常的catch子句前面。 C．如果try子句没有抛出任何异常，则跳过catch子句，转移到finally子句继续执行。 D．当try子句监视的语句块抛出异常时，运行时系统会根据catch子句的顺序，从第一个开始，逐个查找能够捕获该异常的catch子句并执行catch子句内的语句块以完成对异常的处理，然后继续执行后面的catch子句，最后转移到finally子句，执行该子句中的语句块。4．有关throw和throws的说法中不正确的是（C）。 A．throw的作用是抛出异常，后面加的是异常类的对象。 B．throws的作用是向外抛出异常即声明要产生的若干异常，后面加的是异常类的类名。 C．throws只能声明要产生的自定义异常，也就是后面只能加自定义异常类。 D．以上都不对。 5．下列程序运行结果是（C）。 public class E { public static void main(String argv[]){ E m = new E(); System.out.println(m.amethod()); } public int amethod(){
山西煤炭运销集团 蒲县昊锦塬煤业有限公司异常情况处理制度为认真贯彻落实国家、省、市关于集中开展安全生产大检查的工作安排要求，加强我矿信息监控系统管理水平，做好矿井生产过程中井下环境参数的有效监控，保障矿井安全生产，加强煤矿安全生产管理水平及抗灾能力，特制定本矿异常情况处理制度如下： 一、值班人员按《中心岗位责任制》规定，浏览查询煤矿安全信息，发现异常情况及时处理，并认真填写《异常情况报告处理表》，传真至县监控中心。 二、监控室值班人员发现系统发出异常报警后，值班人员必须立即通知监控室主任、分管领导，同时立即通知矿井调度部门，由监控室主任或分管领导组织相关人员对本次异常报警进行原因分析，并按规定程序及时报上一级网络中心。处理结果应记录备案。调度值班人员接到报警、断电信息后，应立即向矿值班领导汇报，矿值班领导按规定指挥现场人员停止工作，断电时撤出人员。处理过程应记录备案。当系统显示井下某一区域瓦斯超限并有可能波及其他区域时，矿井有关人员应按瓦斯事故应急预案手动遥控切断瓦斯可能波及区域的电源。值班人员接到网络中心发出的报警处理指令后，要立即处理落实，并将处理结果向网络中心反馈。 当工作面瓦斯浓度达到报警浓度时，值班人员应立即通知矿值班领导及监控室主任，并填写异常情况处理报告表传真上报至
县监控中心；由分管领导或监控室主任安排相关人员进行原因分析，按照瓦斯超限分析原则：①按人工检测值与甲烷传感器对比分析；②按报警地点的历史曲线对比分析；③按报警地点上风侧检测值对比分析。根据分析结果立即将处理措施下达至矿调度中心按处理措施严格执行。报警期间要采取安全措施，报警消除后将报警的起止时间、分析报告、采取措施和处理结果上报县监控室并存档备案。 三、当煤矿通讯中断、无数据显示时，值班人员要通过传真（或电话）向县监控中心报告，并查明原因，恢复通讯。情况紧急的，由值班人员立即向矿领导汇报，对因故造成通讯中断未及时上报的，要通过电话联系移动公司或长途线务局进行抢修。
实验四异常处理 实验目的 1、掌握异常的概念和Java 异常处理机制。 2、掌握异常的定义、抛出和捕捉处理。 实验内容与要求 1、仔细读下面的JAVA语言源程序，自己给出程序的运行结果 import java.io.*; public class Ch31 { public static void main(String args[])throws IOException { int[] ko=new int[15]; int n,a; String x; BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in)); System.out.print("Enter an integer:"); x=keyin.readLine(); n=Integer.parseInt(x); try { a=110/n; ko[15]=100; System.out.println("此描述无法执行！"); } catch(ArithmeticException e){ System.out.println("除数为0的错误"); } catch(ArrayIndexOutOfBoundsException f) { System.out.println("数组索引值大于数组长度的错误!"); } System.out.println("执行完catch的描述!!!"); } } 2．运行下面的程序，自己给出程序的运行结果。 import java.io.*; public class Ch32{ public Ch32(){ try{ int a[] = new int[2]; a[4] = 3; System.out.println("After handling exception return here?"); }catch(IndexOutOfBoundsException e){ System.err.println("exception msg:" + e.getMessage()); System.err.println("exception string:" + e.toString()); e.printStackTrace(); }finally{
1. 异常机制 异常机制是指当程序出现错误后，程序如何处理。具体来说，异常机制提供了程序退出的安全通道。当出现错误后，程序执行的流程发生改变，程序的控制权转移到异常处理器。 传统的处理异常的办法是，函数返回一个特殊的结果来表示出现异常（通常这个特殊结果是大家约定俗称的），调用该函数的程序负责检查并分析函数返回的结果。这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码与处理异常的代码混爹在一起；由调用函数的程序来分析错误，这就要求客户程序员对库函数有很深的了解。 异常处理的流程： ①遇到错误，方法立即结束，并不返回一个值；同时，抛出一个异常对象。 ②调用该方法的程序也不会继续执行下去，而是搜索一个可以处理该异常的异常处理器，并执行其中的代码。 2 异常的分类 异常的分类： ①异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。 ② Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。 每个类型的异常的特点 Error体系： Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形。应用程序不应该抛出这种类型的对象（一般是由虚拟机抛出）。如果出现这种错误，除了尽力使程序安全退出外，在其他方面是无能为力的。所以，在进行程序设计时，应该更关注Exception体系。 Exception体系包括RuntimeException体系和其他非RuntimeException的体系： ① RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。处理RuntimeException的原则是：如果出现
Java 异常处理总结 找到一个关于异常总结的很详细的文章, 分享下. 异常在我们编程中很重，在适当的位置，合理的处理或者抛出异常，对程序来说至关重要。转：异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C 开始，你也许已经知道如何用if...else... 来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！ Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java 语言设计者的高明之处，也是Java 语言中的一个难点，下面是我对Java 异常知识的一个总结，也算是资源回收一下。 一、Java 异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.doczj.com/doc/fc13378564.html,ng.Error ；如果你用System.out.println(11/0，那么你是因为你用0做了除数，会抛出https://www.doczj.com/doc/fc13378564.html,ng.ArithmeticException 的异常。有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。天有不测风云，人有旦夕祸福，Java 的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。 Java 中的异常用对象来表示。Java 对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class ），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java 语言本身定义的一些基本异常类型，二是用户通过继承Exception 类或者其子类自己定义的异常。Exception 类及其
货物异常应急处置制度 一、目的 确保公司在进行货物运输、装卸、存储等过程中对货物多货、少货、货损、污染、霉变、虫害、火灾、被盗、丢失及其他异常情况进行及时调查分析和处置，并遵守国家相关安全要求。 二、范围 1、本制度适用于货物运输、装卸、存储数量及质量控制； 2、本制度使用货物异常分析及处置。 三、主要职责和权限 1、理货员负责核实出入库货物数量、质量、单据和记录的控制； 2、统计员负责提供货物单据及盘点数量； 3、业务员负责货物异常的追溯、调查及对接客户的处理方案； 4、仓库经理负责处理异常货物。 四、工作程序 1、入库货物多货、少货 （1）货物拆箱时，由理货员依据入库单，清单货物数量。如发现多货或少货，首先与统计员、操作员确认入库单数量是否正确； （2）如确认的确为装箱货物数量异常，则须拍照取证，并及时上报仓库经理、操作员； （3）操作员须及时与客户沟通确认是否继续卸货，待客户确认实际到货数量，并同意卸货后，方可安排叉车工予以卸货； （4）操作员留存客户确认实际到货数量的邮件、微信等截图。 2、出库货物多货、少货 （1）货物装箱时，由理货员依据出库单，查找对应提单号货物存储位置，并检查货物状态，是否有货损、污染、霉变、虫害等情况； （2）如存储期间出现货损、污染、霉变、虫害等情况，则及时报告仓库经理，对异常情况进行调查，必要情况下，须及时通知客户以便出具处理意见； （3）货物检查无异常的，安排并监督叉车工进行装车工作，清点装货数量。 （4）如出库货物到达客户仓库后，被告知货物多货或少货的，则由仓库经理负责调取监控，查看装车视频，清点装车数量，确定为装货时数量异常还是运输过程中数量异常； （5）如装货时少货的，除上报公司外，与客户沟通单独送货还是待下批次货物一同运输； （6）如装货时多货的，除上报公司外，与客户沟通单独退货还是待下批次货物扣除同等数量。 （7）操作员留存客户确认实际到货数量、处理意见的邮件、微信等截图。 3、入库货物货损 （1）货物拆箱时，由理货员依据入库单，检查货物包装。如发现货损情况，则须拍照取证，并及时上报仓库经理、操作员； （2）由仓库经理负责调取监控，查看车辆入场、拆箱视频，确认货损出现原因；