java 为什么需要异常(JAVA异常处理的意义何在为什么要做异常处理,作用是什么)

本篇文章给大家谈谈java 为什么需要异常，以及JAVA异常处理的意义何在为什么要做异常处理,作用是什么对应的知识点，文章可能有点长，但是希望大家可以阅读完，增长自己的知识，最重要的是希望对各位有所帮助，可以解决了您的问题，不要忘了收藏本站喔。

JAVA反射为什么总要异常处理

JAVA中的异常和反射

一、异常

1

、异常概貌：

概念： JAVA会将所有的异常、错误抽象成为一个类，其根本父类为Throwable。异常是程

序中所有出乎意料的结果，用名称代表发生的问题，见名知义。我们对于程序可能出现的错

误应该做出预案。异常处理可以提高我们系统的容错性、健壮性。

java.lang.Throwable类是所有异常和错误的顶层类。其两个直接子类是java.lang.Error和

java.lang.Exception。

 Error

对象表示程序错误，是底层的、不可恢复的严重错误。此时程序一定会退出，

已经失去了运行所必须的物理环境。因为程序已经退出了，所以对于Error错误无法进

行处理。

我们可处理的只是Exception

类的对象表示的程序异常（例外/异常）。

以下区分：

 RuntimeException

（未检查异常）：RuntimeException及其子类都称为运行时异常，它

是（UnChecked Exception），特点是Java编译器不会检查它，可以在编程时避免。也就

是说，当程序中出现此类异常时，即使不用try…catch捕获，或不用throws子句抛出，

还是可以编译通过。比如，除数为0的异常ArrithmeticException，就是运行时异常。

非Runtime

异常（已检查异常）：包括除了RuntimeException及其子类外的其它Exception

类及其子类，都属于已检查异常（Checked Exception）。其特点是Java编译器会检查它，

我们需要用try…catch语句捕获，或用throws子句声明抛出，否则编译不会通过。比如

打开文件时找不到文件，就属于已检查异常。

Throwable

Error

错误

严重底层错误

不可避免

不可处理

Exception

异常

RuntimeException

未检查异常

（可处理可不处理）

比如除0错误、空指针

非Runtime

已检查异常

（必须处理）

比如打开文件时找不到

2

2

、Java

异常处理机制

（1

）try

…

catch

捕获异常（积极处理异常的方式）

try代码块包含了可能发生异常的程序代码，catch块紧随其后，用来捕获并处理异常。

格式如下：

try

{

可能出现异常的代码块}

catch

(Exception

e)

{

进行异常处理}

注意：一次异常捕获只会匹配一次try…catch

catch中要求必须先捕获子类异常再捕获父类异常。

（2

）finally

任何情况下都必须执行的代码段（紧接在try或catch代码块后面）。

finally无论如何都会被执行，除非JVM退出。所以，finally代码块常常用于释放被占

用的资源。比如关闭文件、网络、数据库连接等。

（3

）throws

声明可能会抛出的异常（消极处理异常的方式）

格式：方法名（参数表）throws

后面接要往上抛的异常。

表示该方法对指定的异常不作任何处理，直接抛往上一层。

static void methodA(int i) throws IOException{//一直向上抛(消极处理)

}

public static void main(String[] args) throws IOException{//一直抛到JVM

}

多个异常，用逗号隔开。throws IOException, SQLException

throws后的异常允许多态。比如IOException，会包括抛出其子类。

注意：不允许子类比父类抛出范围更大、更多的异常。

方法覆盖时，修饰符要越来越宽；抛例外则要越来越窄。

throws

和try

…

catch

经常配合使用，把异常传递给最能处理此异常的方法中，体现各

司其职的特点。

Java

中处理异常方式

消极throws用在方法的声明上

积极try…catch…finally

public static int fn(int b){

try{

return b/2;

}catch(Exception e){

return 0;

}finally{

return b;//返回的结果是一定是b;

}

}

3

（4

）throw

抛出异常

打个比方：

public void eat() throws FoodException{//自定义FoodException是以下异常的父类

if(没有食物) throw new NoFoodException(“呵呵，没有食物”);

if(发现苍蝇) throw new FoundFlyException(“哎呀，发现半只苍蝇”);

}

比较throw

和throws

：

 throw

是一个语句，它出现在方法体中，用来抛出异常对象。

 throws

是出现在方法声明中，表示本方法中会有异常对象向上（调用者）抛出。

 throws

后写的是异常类型； throw

后写的是要抛出的异常对象。

（5

）异常处理流程

try…catch…finally，如果遇到return和System.exit()语句：

一如果在finally之前遇到System.exit()则finally语句不再执行，这是finally不被执行

的唯一情况。因为java.lang.System类的静态方法exit()用于终止当前的Java虚拟机进程。exit()

的参数表示程序终止时的状态码，0表示正常终止，非0表示异常终止。

二return语句用于退出本方法。如果在try或者catch代码块中遇到return语句时，若

有finally语句块，会先执行finally代码块。

三不要在finally代码块中使用return语句。因为这样会导致两种潜在错误：A.覆盖了

try或catch块中的return语句； B.导致丢失异常。

try{

①

②

③

} catch(XxxException e){

④

} finally{

⑤

}

⑥

情况一：没有异常，处理顺序为①②③⑤⑥

情况二：在②处有异常，①②④⑤⑥

情况三：有异常，没有被捕获，①②⑤终止

情况四：如果③后有return语句，①②③⑤

情况五：如果遇到System.exit()，则⑤不执行

允许的处理方式：

① try…catch()

② try…finally//与throws配合使用

③ try…catch…finally

④ try…catch(){} catch(){}…//配多个catch

//注意范围大的异常要写在后面

4

（6

）异常处理规则：

①只有在异常情况下才使用异常处理机制；

②保证操作要么一起成功，要么一起失败；

③ try代码块不要太大；

④ catch子句中指定具体的异常类型；

⑤早抛出，晚捕获。

3

编程中为什么需要异常处理

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，这时又分为两种情况进行处理：�0�5如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；如果catch块执行正常，那么try-catch程序块的结果就是“正常完成”；如果该catch块由于原因R突然中止，那么try-catch程序块的结果就是“由于原因R突然中止（completes abruptly）”。�0�5如果异常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块的居于就会被执行，这时分为以下两种情况：�0�5如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。�0�5如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）” 2．如果try语句块在执行过程中碰到异常V，这时又分为两种情况进行处理：�0�5如果异常V能够被与try相应的catch块catch到，那么第一个catch到这个异常的catch块（也是离try最近的一个与异常V匹配的catch块）将被执行；这时就会有两种执行结果：�0�5如果catch块执行正常，那么finally块将会被执行，这时分为两种情况：�0�5如果finally块执行顺利，那么整个try-catch-finally程序块正常完成。�0�5如果finally块由于原因R突然中止，那么try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”�0�5如果catch块由于原因R突然中止，那么finally模块将被执行，分为两种情况：�0�5如果如果finally块执行顺利，那么整个try-catch-finally程序块的结局是“由于原因R突然中止（completes abruptly）”。�0�5如果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为例：如果你一定要使

JAVA异常处理的意义何在为什么要做异常处理,作用是什么

代替日渐衰落的error code方法的新法，提供error code所未能具体的优势。

异常处理分离了接收和处理错误代码。这个功能理清了编程者的思绪，也帮助代码增强了可读性，方便了维护者的阅读和理解。

异常处理（又称为错误处理）功能提供了处理程序运行时出现的任何意外或异常情况的方法。异常处理使用try、catch和 finally关键字来尝试可能未成功的操作，处理失败，以及在事后清理资源。

扩展资料

程序设计的要求之一就是程序的健壮性。希望程序在运行时能够不出或者少出问题。但是，在程序的实际运行时，总会有一些因素导致程序不能正常运行。

在设计算法时，往往对算法的正常逻辑处理流程设计得比较准确，对异常情况的处理反而不容易设计全面，导致程序在出现异常情况时崩溃。如果软件出现这种情况会给用户带来极不友好的体验。

例如：试设计一个程序，运行后提示用户输入两个整数。两个整数用空格隔开，用户输入后，程序显示出两个数字的和。这个程序正常的逻辑处理非常简单，但普用户输入的两个字符串不是整数，程序应该给出提示，否则程序有可能会崩溃。因此针对异常情况的处理也是非常重要的，当然有时这种处理会比较复杂。

参考资料来源：百度百科-异常处理机制

参考资料来源：百度百科-异常处理

关于java 为什么需要异常到此分享完毕，希望能帮助到您。