trycatch错误处理.docx

trycatch错误处理.docx

《trycatch错误处理.docx》由会员分享，可在线阅读，更多相关《trycatch错误处理.docx（13页珍藏版）》请在冰豆网上搜索。

trycatch错误处理

try{

//代码区

}catch（Exceptione）{

//异常处理

}

代码区如果有错误，就会返回所写异常的处理。

首先要清楚，如果没有try的话，出现异常会导致程序崩溃。

而try则可以保证程序的正常运行下去，比如说：

try{

inti=1/0;

}catch（Exceptione）{

........

}

一个计算的话，如果除数为0，则会报错，如果没有try的话，程序直接崩溃。

用try的话，则可以让程序运行下去，并且输出为什么出错！

trycatch是捕捉try部分的异常，当你没有trycatch的时候，如果出现异常则程序报错，加上trycatch，出现异常程序正常运行，只是把错误信息存储到Exception里，所以catch是用来提取异常信息的，你可以在Catch部分加上一句System.out.println（e.ToString（））;，如果出现异常可以把异常打印出来

java的异常处理机制（try…catch…finally）

1引子

try…catch…finally恐怕是大家再熟悉不过的语句了，而且感觉用起来也是很简单，逻辑上似乎也是很容易理解。

不过，我亲自体验的“教训”告诉我，这个东西可不是想象中的那么简单、听话。

不信？

那你看看下面的代码，“猜猜”它执行后的结果会是什么？

不要往后看答案、也不许执行代码看真正答案哦。

如果你的答案是正确，那么这篇文章你就不用浪费时间看啦。

publicclassTestException

{

    publicTestException（）

    {

    }

    booleantestEx（）throwsException

    {

        booleanret=true;

        try

        {

            ret=testEx1（）;

        }

        catch（Exceptione）

        {

            System.out.println（"testEx,catchexception"）;

            ret=false;

            throwe;

        }

        finally

        {

            System.out.println（"testEx,finally;returnvalue="+ret）;

            returnret;

        }

    }

    booleantestEx1（）throwsException

    {

        booleanret=true;

        try

        {

            ret=testEx2（）;

            if（!

ret）

            {

                returnfalse;

            }

            System.out.println（"testEx1,attheendoftry"）;

            returnret;

        }

        catch（Exceptione）

        {

            System.out.println（"testEx1,catchexception"）;

            ret=false;

            throwe;

        }

        finally

        {

            System.out.println（"testEx1,finally;returnvalue="+ret）;

            returnret;

        }

    }

    booleantestEx2（）throwsException

    {

        booleanret=true;

        try

        {

            intb=12;

            intc;

            for（inti=2;i>=-2;i--）

            {

                c=b/i;

                System.out.println（"i="+i）;

            }

            returntrue;

        }

        catch（Exceptione）

        {

            System.out.println（"testEx2,catchexception"）;

            ret=false;

            throwe;

        }

        finally

        {

            System.out.println（"testEx2,finally;returnvalue="+ret）;

            returnret;

        }

    }

    publicstaticvoidmain（String[]args）

    {

        TestExceptiontestException1=newTestException（）;

        try

        {

            testException1.testEx（）;

        }

        catch（Exceptione）

        {

            e.printStackTrace（）;

        }

    }

}

你的答案是什么？

是下面的答案吗？

i=2

i=1

testEx2,catchexception

testEx2,finally;returnvalue=false

testEx1,catchexception

testEx1,finally;returnvalue=false

testEx,catchexception

testEx,finally;returnvalue=false

如果你的答案真的如上面所说，那么你错啦。

^_^，那就建议你仔细看一看这篇文章或者拿上面的代码按各种不同的情况修改、执行、测试，你会发现有很多事情不是原来想象中的那么简单的。

现在公布正确答案：

i=2

i=1

testEx2,catchexception

testEx2,finally;returnvalue=false

testEx1,finally;returnvalue=false

testEx,finally;returnvalue=false

2基础知识

2.1相关概念

例外是在程序运行过程中发生的异常事件，比如除0溢出、数组越界、文件找不到等，这些事件的发生将阻止程序的正常运行。

为了加强程序的鲁棒性，程序设计时，必须考虑到可能发生的异常事件并做出相应的处理。

C语言中，通过使用if语句来判断是否出现了例外，同时，调用函数通过被调用函数的返回值感知在被调用函数中产生的例外事件并进行处理。

全程变量ErroNo常常用来反映一个异常事件的类型。

但是，这种错误处理机制会导致不少问题。

Java通过面向对象的方法来处理例外。

在一个方法的运行过程中，如果发生了例外，则这个方法生成代表该例外的一个对象，并把它交给运行时系统，运行时系统寻找相应的代码来处理这一例外。

我们把生成例外对象并把它提交给运行时系统的过程称为抛弃（throw）一个例外。

运行时系统在方法的调用栈中查找，从生成例外的方法开始进行回朔，直到找到包含相应例外处理的方法为止，这一个过程称为捕获（catch）一个例外。

2.2Throwable类及其子类

　用面向对象的方法处理例外，就必须建立类的层次。

类Throwable位于这一类层次的最顶层，只有它的后代才可以做为一个例外被抛弃。

图1表示了例外处理的类层次。

从图中可以看出，类Throwable有两个直接子类：

Error和Exception。

Error类对象（如动态连接错误等），由Java虚拟机生成并抛弃（通常，Java程序不对这类例外进行处理）；Exception类对象是Java程序处理或抛弃的对象。

它有各种不同的子类分别对应于不同类型的例外。

其中类RuntimeException代表运行时由Java虚拟机生成的例外，如算术运算例外ArithmeticException（由除0错等导致）、数组越界例外ArrayIndexOutOfBoundsException等；其它则为非运行时例外，如输入输出例外IOException等。

Java编译器要求Java程序必须捕获或声明所有的非运行时例外，但对运行时例外可以不做处理。

2.3　异常处理关键字

Java的异常处理是通过5个关键字来实现的：

try，catch，throw，throws，finally。

JB的在线帮助中对这几个关键字是这样解释的：

Throws:

  Liststheexceptionsamethodcouldthrow.

Throw:

   Transferscontrolofthemethodtotheexceptionhandler.

Try：

    Openingexception-handlingstatement.

Catch：

  Capturestheexception.

Finally：

Runsitscodebeforeterminatingtheprogram.

2.3.1try语句　

try语句用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。

2.3.2catch语句　

catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。

例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。

catch语句可以有多个，分别处理不同类的例外。

Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。

这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。

也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。

2.3.3finally语句　

try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。

通过finally语句可以指定一块代码。

无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。

通常在finally语句中可以进行资源的清除工作。

如关闭打开的文件等。

2.3.4throws语句　

throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。

对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的异常的类型。

如果异常的类型是Error或RuntimeException，或它们的子类，这个规则不起作用，因为这在程序的正常部分中是不期待出现的。

如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。

2.3.5throw语句　

throw总是出现在函数体中，用来抛出一个异常。

程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

3关键字及其中语句流程详解

3.1try的嵌套

你可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部，写另一个try语句保护其他代码。

每当遇到一个try语句，异常的框架就放到堆栈上面，直到所有的try语句都完成。

如果下一级的try语句没有对某种异常进行处理，堆栈就会展开，直到遇到有处理这种异常的try语句。

下面是一个try语句嵌套的例子。

classMultiNest{

    staticvoidprocedure（）{

        try{

            inta=0;

            intb=42/a;

        }catch（java.lang.ArithmeticExceptione）{

            System.out.println（"inprocedure,catchArithmeticException:

"+e）;

        }

    }

    publicstaticvoidmain（Stringargs[]）{

        try{

            procedure（）;

        }catch（java.lang.Exceptione）{

            System.out.println（"inmain,catchException:

"+e）;

        }

    }

}

这个例子执行的结果为：

inprocedure,catchArithmeticException:

java.lang.ArithmeticException:

/byzero

成员函数procedure里有自己的try/catch控制，所以main不用去处理ArrayIndexOutOfBoundsException；当然如果如同最开始我们做测试的例子一样，在procedure中catch到异常时使用throwe;语句将异常抛出，那么main当然还是能够捕捉并处理这个procedure抛出来的异常。

例如在procedure函数的catch中的System.out语句后面增加throwe;语句之后，执行结果就变为：

inprocedure,catchArithmeticException:

java.lang.ArithmeticException:

/byzero

inmain,catchException:

java.lang.ArithmeticException:

/byzero

3.2try-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突然中止（completesabruptly）”。

-->如果异常V没有catch块与之匹配，那么这个try-catch程序块的结果就是“由于抛出异常V而突然中止（completesabruptly）”。

    3．如果try由于其他原因R突然中止（completesabruptly），那么这个try-catch程序块的结果就是“由于原因R突然中止（completesabruptly）”。

3.3try-catch-finally程序块的执行流程以及执行结果

try-catch-finally程序块的执行流程以及执行结果比较复杂。

首先执行的是try语句块中的语句，这时可能会有以下三种情况：

1．如果try块中所有语句正常执行完毕，那么finally块的居于就会被执行，这时分为以下两种情况：

-->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

-->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completesabruptly）”

2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：

-->如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：

-->如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：

-->如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。

-->如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completesabruptly）”

-->如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：

-->如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completesabruptly）”。

-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completesabruptly）”，原因R将被抛弃。

（注意，这里就正好和我们的例子相符合，虽然我们在testEx2中使用throwe抛出了异常，但是由于testEx2中有finally块，而finally块的执行结果是completeabruptly的（别小看这个用得最多的return，它也是一种导致completeabruptly的原因之一啊——后文中有关于导致completeabruptly的原因分析），所以整个try-catch-finally程序块的结果是“completeabruptly”，所以在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而突然中止（completesabruptly）”。

-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completesabruptly）”，异常V将被抛弃。

3．如果try由于其他原因R突然中止（completesabruptly），那么finally块被执行，分为两种情况：

-->如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completesabruptly）”。

-->如果finally块由于原因S突然中止，那么整个try-catch-finally程序块的结局是“由于原因S突然中止（completesabruptly）”，原因R将被抛弃。

3.4try-catch-finally程序块中的return

从上面的try-catch-finally程序块的执行流程以及执行结果一节中可以看出无论try或catch中发生了什么情况，finally都是会被执行的，那么写在try或者catch中的return语句也就不会真正的从该函数中跳出了，它的作用在这种情况下就变成了将控制权（语句流程）转到finally块中；这种情况下一定要注意返回值的处理。

例如，在try或者catch中returnfalse了，而在finally中又returntrue，那么这种情况下不要期待你的try或者catch中的returnfalse的返回值false被上级调用函数获取到，上级调用函数能够获取到的只是finally中的返回值，因为try或者catch中的return语句只是转移控制权的作用。

3.5如何抛出异常

如果你知道你写的某个函数有可能抛出异常，而你又不想在这个函数中对异常进行处理，只是想把它抛出去让调用这个函数的上级调用函数进行处理，那么有两种方式可供选择：

第一种方式：

直接在函数头中throwsSomeException，函数体中不需要try/catch。

比如将最开始的例子中的testEx2改为下面的方式，那么testEx1就能捕捉到testEx2抛出的异常了。

    booleantestEx2（）throwsException{

        booleanret=true;

        intb=12;

        intc;

        for（inti=2;i>=-2;i--）{

            c=b/i;

            System.out.println（"i="+i）;

        }

        returntrue;   

}

第二种方式：

使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常。

例如上面的testEx2改为下面的方式，testEx1也能捕获到它抛出的异常：

    booleantestEx2（）throwsException{

        booleanret=true;

        try{

            intb=12;

            intc;

            for（inti=2;i>=-2;i--）{

                c=b