异常处理_异常处理机制 - CSDN
异常处理 订阅
异常处理,英文名为exceptional handling, 是代替日渐衰落的error code方法的新法,提供error code 所未能具体的优势。异常处理分离了接收和处理错误代码。这个功能理清了编程者的思绪,也帮助代码增强了可读性,方便了维护者的阅读和理解。 异常处理(又称为错误处理)功能提供了处理程序运行时出现的任何意外或异常情况的方法。异常处理使用 try、catch 和 finally 关键字来尝试可能未成功的操作,处理失败,以及在事后清理资源。异常处理,是编程语言或计算机硬件里的一种机制,用于处理软件或信息系统中出现的异常状况(即超出程序正常执行流程的某些特殊条件)。 展开全文
异常处理,英文名为exceptional handling, 是代替日渐衰落的error code方法的新法,提供error code 所未能具体的优势。异常处理分离了接收和处理错误代码。这个功能理清了编程者的思绪,也帮助代码增强了可读性,方便了维护者的阅读和理解。 异常处理(又称为错误处理)功能提供了处理程序运行时出现的任何意外或异常情况的方法。异常处理使用 try、catch 和 finally 关键字来尝试可能未成功的操作,处理失败,以及在事后清理资源。异常处理,是编程语言或计算机硬件里的一种机制,用于处理软件或信息系统中出现的异常状况(即超出程序正常执行流程的某些特殊条件)。
信息
领    域
计算机
关键字
try、catch 和 finally 关键字
代    替
日渐衰落的error code方法
作    用
提供了处理异常情况的方法
中文名
异常处理
外文名
exceptional handling
又    称
错误处理
异常处理概述
异常处理,是编程语言或计算机硬件里的一种机制,用于处理软件或信息系统中出现的异常状况(即超出程序正常执行流程的某些特殊条件)。各种编程语言在处理异常方面具有非常显著的不同点(错误检测与异常处理区别在于:错误检测是在正常的程序流中,处理不可预见问题的代码,例如一个调用操作未能成功结束)。某些编程语言有这样的函数:当输入存在非法数据时不能被安全地调用,或者返回值不能与异常进行有效的区别。例如,C语言中的atoi函数(ASCII串到整数的转换)在输入非法时可以返回0。在这种情况下编程者需要另外进行错误检测(可能通过某些辅助全局变量如C的errno),或进行输入检验(如通过正则表达式),或者共同使用这两种方法。通过异常处理,我们可以对用户在程序中的非法输入进行控制和提示,以防程序崩溃。从进程的视角,硬件中断相当于可恢复异常,虽然中断一般与程序流本身无关。从子程序编程者的视角,异常是很有用的一种机制,用于通知外界该子程序不能正常执行。如输入的数据无效(例如除数是0),或所需资源不可用(例如文件丢失)。如果系统没有异常机制,则编程者需要用返回值来标示发生了哪些错误。
收起全文
精华内容
参与话题
  • java 异常分类和处理机制

    千次阅读 2019-02-27 12:39:20
     Java语言中的异常处理机制就解决的上述问题,把错误与异常的管理带到了面向对象的世界         Java语言定义了很多异常类,将运行错误和异常的信息和处理方法封装在了异常类中,帮助程序员检查和控制...

        一、背景介绍

           程序在运行过程中发生错误或异常情况是不可避免的,如果每一个运行时错误都由程序员手动控制和处理,其工作量是不可想象的。

     

         Java语言中的异常处理机制就解决的上述问题,把错误与异常的管理带到了面向对象的世界

     

     

     

     

    Java语言定义了很多异常类,将运行错误和异常的信息和处理方法封装在了异常类中,帮助程序员检查和控制异常。即Java造好了工具,程序员只要学会使用工具。

     

    二、java异常分类

    Java语言按照错误严重性,从throwale根类衍生出Error和Exception两大派系

    Error(错误):程序在执行过程中所遇到的硬件或操作系统的错误。错误对程序而言是致命的,将导致程序无法运行。常见的错误有内存溢出,jvm虚拟机自身的非正常运行,calss文件没有主方法。程序本生是不能处理错误的,只能依靠外界干预。Error是系统内部的错误,由jvm抛出,交给系统来处理。

     

     

     

    EXCEPTION(异常):是程序正常运行中,可以预料的意外情况。比如数据库连接中断,空指针,数组下标越界。异常出现可以导致程序非正常终止,也可以预先检测,被捕获处理掉,使程序继续运行。

     

     

     

    EXCEPTION(异常)按照性质,又分为编译异常(可检测)和运行时异常(不可检测)。

     

    编译时异常:又叫可检查异常,通常时由语法错和环境因素(外部资源)造成的异常。比如输入输出异常IOException,数据库操作SQLException。其特点是,Java语言强制要求捕获和处理所有非运行时异常。通过行为规范,强化程序的健壮性和安全性。

     

    运行时异常:又叫不检查异常RuntimeException,这些异常一般是由程序逻辑错误引起的,即语义错。比如算术异常,空指针异常NullPointerException,下标越界IndexOutOfBoundsException。运行时异常应该在程序测试期间被暴露出来,由程序员去调试,而避免捕获。

     

    所以,java语言处理运行时错误有三种方式,

     

    一是程序不能处理的错误,二是程序应该避免而可以不去捕获的运行时异常,三是必须捕获的非运行时异常。

     

    三、java异常处理机制

     

     

    java默认处理机制:

     

    1抛出异常

     

     

    2终止程序

     

    异常处理程序机制:

     

    1抛出异常

     

     

    2try-catch-finally 捕获和处理异常

     

     

     

    当Java程序运行到某个方法发生异常时,产生一个对应异常类对象,包含异常事件类型,发生异常是应用程序的状态,和调用过程等信息,然后抛出,运行系统开始查找有没又匹配异常处理程序,么有,就中断程序,有就将控制权交个程序处理程序,处理异常。

     异常处理是程序开发中必不可少操作之一,但如何正确优雅的对异常进行处理确是一门学问,笔者在此处转载了一篇微博的内容,来谈一谈何对异常进行处理的。

    四、如何优雅的设计异常

    4.1 如何选择异常

    从开发经验来看,如果在一个应用中,需要开发一个方法(如某个功能的service方法),这个方法如果中间可能出现异常,那么你需要考虑这个异常出现之后是否调用者可以处理,并且你是否希望调用者进行处理,如果调用者可以处理,并且你也希望调用者进行处理,那么就要抛出受检异常,提醒调用者在使用你的方法时,考虑到如果抛出异常时如果进行处理,相似的,如果在写某个方法时,你认为这是个偶然异常,理论上说,你觉得运行时可能会碰到什么问题,而这些问题也许不是必然发生的,也不需要调用者显示的通过异常来判断业务流程操作的,那么这时就可以使用一个RuntimeException这样的非受检异常.

    4.2 什么时候才需要抛异常

    首先我们需要了解一个问题,什么时候才需要抛异常?异常的设计是方便给开发者使用的,但不是乱用的,笔者对于什么时候抛异常这个问题也问了很多朋友,能给出准确答案的确实不多。其实这个问题很简单,如果你觉得某些”问题”解决不了了,那么你就可以抛出异常了。比如,你在写一个service,其中在写到某段代码处,你发现可能会产生问题,那么就请抛出异常吧,相信我,你此时抛出异常将是一个最佳时机。

    4.3 应该抛出怎样的异常

    了解完了什么时候才需要抛出异常后,我们再思考一个问题,真的当我们抛出异常时,我们应该选用怎样的异常呢?究竟是受检异常还是非受检异常呢(RuntimeException)呢?我来举例说明一下这个问题,先从受检异常说起,比如说有这样一个业务逻辑,需要从某文件中读取某个数据,这个读取操作可能是由于文件被删除等其他问题导致无法获取从而出现读取错误,那么就要从redis或mysql数据库中再去获取此数据,参考如下代码,getKey(Integer)为入口程序.

     

    ok,看了以上代码以后,你也许心中有一些想法,原来受检异常可以控制义务逻辑,对,没错,通过受检异常真的可以控制业务逻辑,但是切记不要这样使用,我们应该合理的抛出异常,因为程序本身才是流程,异常的作用仅仅是当你进行不下去的时候找到的一个借口而已,它并不能当成控制程序流程的入口或出口,如果这样使用的话,是在将异常的作用扩大化,这样将会导致代码复杂程度的增加,耦合性会提高,代码可读性降低等问题。那么就一定不要使用这样的异常吗?其实也不是,在真的有这样的需求的时候,我们可以这样使用,只是切记,不要把它真的当成控制流程的工具或手段。那么究竟什么时候才要抛出这样的异常呢?要考虑,如果调用者调用出错后,一定要让调用者对此错误进行处理才可以,满足这样的要求时,我们才会考虑使用受检异常。
    接下来,我们来看一下非受检异常呢(RuntimeException),对于RuntimeException这种异常,我们其实很多见,比如java.lang.NullPointerException/java.lang.IllegalArgumentException等,那么这种异常我们时候抛出呢?当我们在写某个方法的时候,可能会偶然遇到某个错误,我们认为这个问题时运行时可能为发生的,并且理论上讲,没有这个问题的话,程序将会正常执行的时候,它不强制要求调用者一定要捕获这个异常,此时抛出RuntimeException异常,举个例子,当传来一个路径的时候,需要返回一个路径对应的File对象:

    上述例子表明,如果调用者调用getFiles(String)的时候如果path是空,那么就抛出空指针异常(它是RuntimeException的子类),调用者不用显示的进行try…catch…操作进行强制处理.这就要求调用者在调用这样的方法时先进行验证,避免发生RuntimeException.如下:

    4.4 应该选用哪种异常

    通过以上的描述和举例,可以总结出一个结论,RuntimeException异常和受检异常之间的区别就是:是否强制要求调用者必须处理此异常,如果强制要求调用者必须进行处理,那么就使用受检异常,否则就选择非受检异常(RuntimeException)。一般来讲,如果没有特殊的要求,我们建议使用RuntimeException异常。

    4.5 何优雅的设计java异常示例

    domain介绍

    根据项目场景来看,需要两个domain模型,一个是用户实体,一个是地址实体.
    Address domain如下:


     User domain如下:      

    ok,上边是一个模型关系,用户-收货地址的关系是1-n的关系。上边的@Data是使用了一个叫做lombok的工具,它自动生成了Setter和Getter等方法,用起来非常方便,感兴趣的读者可以自行了解一下。

    dao介绍

    数据连接层,我们使用了spring-data-jpa这个框架,它要求我们只需要继承框架提供的接口,并且按照约定对方法进行取名,就可以完成我们想要的数据库操作。
    用户数据库操作如下:

    收货地址操作如下:

     

    正如读者所看到的,我们的DAO只需要继承JpaRepository,它就已经帮我们完成了基本的CURD等操作,如果想了解更多关于spring-data的这个项目,请参考一下spring的官方文档,它比不方案我们对异常的研究。

    Service异常设计

    ok,终于到了我们的重点了,我们要完成service一些的部分操作:添加收货地址,删除收货地址,获取收货地址列表.
    首先看我的service接口定义:

    我们来关注一下实现:

    添加收货地址

    首先再来看一下之前整理的约束条件:

    入参:

    1. 用户id

    2. 收货地址实体信息

    约束:

    1. 用户id不能为空,且此用户确实是存在的

    2. 收货地址的必要字段不能为空

    3. 如果用户还没有收货地址,当此收货地址创建时设置成默认收货地址

    先看以下代码实现:

    其中,已经完成了上述所描述的三点约束条件,当三点约束条件都满足时,才可以进行正常的业务逻辑,否则将抛出异常(一般在此处建议抛出运行时异常-RuntimeException)。

    介绍以下以上我所用到的技术:

    1.Preconfitions.checkNotNull(T t)这个是使用Guava中的com.google.common.base.Preconditions进行判断的,因为service中用到的验证较多,所以建议将Preconfitions改成静态导入的方式:

    当然Guava的github中的说明也建议我们这样使用。

    2.BeanValidators.validateWithException(validator, address);
    这个使用了hibernate实现的jsr 303规范来做的,需要传入一个validator和一个需要验证的实体,那么validator是如何获取的呢,如下:

    他将获取一个Validator对象,然后我们在service中进行注入便可以使用了:

    那么BeanValidators这个类是如何实现的?其实实现方式很简单,只要去判断jsr 303的标注注解就ok了。
    那么jsr 303的注解写在哪里了呢?当然是写在address实体类中了:

    写好你需要的约束条件来进行判断,如果合理的话,才可以进行业务操作,从而对数据库进行操作。

     

    这块的验证是必须的,一个最主要的原因是:这样的验证可以避免脏数据的插入。如果读者有正式上线的经验的话,就可以理解这样的一个事情,任何的代码错误都可以容忍和修改,但是如果出现了脏数据问题,那么它有可能是一个毁灭性的灾难。程序的问题可以修改,但是脏数据的出现有可能无法恢复。所以这就是为什么在service中一定要判断好约束条件,再进行业务逻辑操作的原因了。

     

    此处的判断为业务逻辑判断,是从业务角度来进行筛选判断的,除此之外,有可能在很多场景中都会有不同的业务条件约束,只需要按照要求来做就好。

    对于约束条件的总结如下:

     

    1. 基本判断约束(null值等基本判断)

    2. 实体属性约束(满足jsr 303等基础判断)

    3. 业务条件约束(需求提出的不同的业务约束)

     

    当这个三点都满足时,才可以进行下一步操作

     

    ok,基本介绍了如何做一个基础的判断,那么再回到异常的设计问题上,上述代码已经很清楚的描述如何在适当的位置合理的判断一个异常了,那么如何合理的抛出异常呢?

     

    只抛出RuntimeException就算是优雅的抛出异常吗?当然不是,对于service中的抛出异常,笔者认为大致有两种抛出的方法:

     

    1. 抛出带状态码RumtimeException异常

    2. 抛出指定类型的RuntimeException异常

     

    相对这两种异常的方式进行结束,第一种异常指的是我所有的异常都抛RuntimeException异常,但是需要带一个状态码,调用者可以根据状态码再去查询究竟service抛出了一个什么样的异常。

     

    第二种异常是指在service中抛出什么样的异常就自定义一个指定的异常错误,然后在进行抛出异常。

     

    一般来讲,如果系统没有别的特殊需求的时候,在开发设计中,建议使用第二种方式。但是比如说像基础判断的异常,就可以完全使用guava给我们提供的类库进行操作。jsr 303异常也可以使用自己封装好的异常判断类进行操作,因为这两种异常都是属于基础判断,不需要为它们指定特殊的异常。但是对于第三点义务条件约束判断抛出的异常,就需要抛出指定类型的异常了。

    定义一个特定的异常类来进行这个义务异常的判断:

    然后将此处改为:

    ok,通过以上对service层的修改,代码更改如下:

     

     

     

    展开全文
  • java中异常的捕获及处理

    万次阅读 多人点赞 2019-03-16 15:59:15
    一、Java异常简介 什么是异常? 程序运行时,发生的不被期望的事件,它阻止了程序按照...异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续...

    一、Java异常简介

    什么是异常?
    程序运行时,发生的不被期望的事件,它阻止了程序按照程序员的预期正常执行,这就是异常。异常发生时,是任程序自生自灭,立刻退出终止。在Java中即,Java在编译或运行或者运行过程中出现的错误

    Java提供了更加优秀的解决办法:异常处理机制。

    异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续执行,且保持代码的清晰。
    Java中的异常可以是函数中的语句执行时引发的,也可以是程序员通过throw 语句手动抛出的,只要在Java程序中产生了异常,就会用一个对应类型的异常对象来封装异常,JRE就会试图寻找异常处理程序来处理异常。

    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 -- 用在方法签名中,用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出,就表示在主方法里面可以不用强制性进行异常处理,如果出现了异常,就交给JVM进行默认处理,则此时会导致程序中断执行。

    产生异常的原因:

    • 用户输入了非法数据。
    • 要打开的文件不存在。
    • 网络通信时连接中断,或者JVM内存溢出。

    这些异常有的是因为用户错误引起,有的是程序错误引起的,还有其它一些是因为物理错误引起的。

    三种类型的异常:

    • 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
    • 运行时异常: 运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
    • 错误: 错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

    二、Java异常的分类

    异常的根接口Throwable,其下有2个子接口,Error和Exception。

    •  Error:指的是JVM错误,这时的程序并没有执行,无法处理;
    • Exception:指的是程序运行中产生的异常,用户可以使用处理格式处理。

    Java 内置异常类

    Java 语言定义了一些异常类在 java.lang 标准包中。

    标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的,所以大部分从运行时异常类继承而来的异常都可以直接使用。

    Java 根据各个类库也定义了一些其他的异常,下面的表中列出了 Java 的非检查性异常

    异常 描述
    ArithmeticException 当出现异常的运算条件时,抛出此异常。例如,一个整数"除以零"时,抛出此类的一个实例。
    ArrayIndexOutOfBoundsException 用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小,则该索引为非法索引。
    ArrayStoreException 试图将错误类型的对象存储到一个对象数组时抛出的异常。
    ClassCastException 当试图将对象强制转换为不是实例的子类时,抛出该异常。
    IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
    IllegalMonitorStateException 抛出的异常表明某一线程已经试图等待对象的监视器,或者试图通知其他正在等待对象的监视器而本身没有指定监视器的线程。
    IllegalStateException 在非法或不适当的时间调用方法时产生的信号。换句话说,即 Java 环境或 Java 应用程序没有处于请求操作所要求的适当状态下。
    IllegalThreadStateException 线程没有处于请求操作所要求的适当状态时抛出的异常。
    IndexOutOfBoundsException 指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出。
    NegativeArraySizeException 如果应用程序试图创建大小为负的数组,则抛出该异常。
    NullPointerException 当应用程序试图在需要对象的地方使用 null 时,抛出该异常
    NumberFormatException 当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常。
    SecurityException 由安全管理器抛出的异常,指示存在安全侵犯。
    StringIndexOutOfBoundsException 此异常由 String 方法抛出,指示索引或者为负,或者超出字符串的大小。
    UnsupportedOperationException 当不支持请求的操作时,抛出该异常。

    下面的表中列出了 Java 定义在 java.lang 包中的检查性异常类

    异常 描述
    ClassNotFoundException 应用程序试图加载类时,找不到相应的类,抛出该异常。
    CloneNotSupportedException 当调用 Object 类中的 clone 方法克隆对象,但该对象的类无法实现 Cloneable 接口时,抛出该异常。
    IllegalAccessException 拒绝访问一个类的时候,抛出该异常。
    InstantiationException 当试图使用 Class 类中的 newInstance 方法创建一个类的实例,而指定的类对象因为是一个接口或是一个抽象类而无法实例化时,抛出该异常。
    InterruptedException 一个线程被另一个线程中断,抛出该异常。
    NoSuchFieldException 请求的变量不存在
    NoSuchMethodException 请求的方法不存在

    异常方法

    下面的列表是 Throwable 类的主要方法:

    序号 方法及说明
    1 public String getMessage()
    返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
    2 public Throwable getCause()
    返回一个Throwable 对象代表异常原因。
    3 public String toString()
    使用getMessage()的结果返回类的串级名字。
    4 public void printStackTrace()
    打印toString()结果和栈层次到System.err,即错误输出流。
    5 public StackTraceElement [] getStackTrace()
    返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。
    6 public Throwable fillInStackTrace()
    用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。

    三、异常的使用及执行流程

    1、异常的处理方案

    try...catch、try...catch...finally、try...finally
        try{
            可能会发生的异常
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }catch(异常类型 异常名(变量)){
            针对异常进行处理的代码
        }...
        [finally{
            释放资源代码;
        }]

    注意:

    • catch 不能独立于 try 存在。
    • catch里面不能没有内容
    • 在 try/catch 后面添加 finally 块并非强制性要求的。
    • try 代码后不能既没 catch 块也没 finally 块。
    • try里面越少越好。
    • try, catch, finally 块之间不能添加任何代码。
    • finally里面的代码最终一定会执行(除了JVM退出)
    • 如果程序可能存在多个异常,需要多个catch进行捕获。
    • 异常如果是同级关系,catch谁前谁后没有关系
      如果异常之间存在上下级关系,上级需要放在后面

    2、异常的执行流程

    Error与Exception的区别:

    Error(错误)是系统中的错误,程序员是不能改变的和处理的,是在程序编译时出现的错误,只能通过修改程序才能修正。一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。

    Exception(异常)表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。

    在catch捕获异常时,为什么不考虑使用Throwable类型,而只是使用Exception来进行接收?

    Throwable表示的范围要比Exception大。实际上程序使用Throwable来进行处理,没有任何语法问题,但是却会存在逻辑问题。因为此时出现的(或者说用户能够处理的)只有Exception类型,而如果使用Throwable接收,还会表示可以处理Error的错误,而用户是处理不了Error错误的,所以在开发中用户可以处理的异常都要求以Exception类为主。

    异常是一起处理好还是分开处理好?

    根据实际的开发要求是否严格来决定。在实际的项目开发项目工作中,所有的异常是统一使用Exception处理还是分开处理,完全根据开发者的项目开发标准来决定。如果项目开发环境严谨,基本上要求针对每一种异常分别进行处理,并且要详细记录下异常产生的时间以及产生的位置,这样可以方便程序维护人员进行代码的维护。再次注意:处理多个异常时,捕获范围小的异常要放在捕获范围大的异常之前处理。

    throw和throws的区别?

    throw和throws都是在异常处理中使用的关键字,区别如下:

    • throw:指的是在方法中人为抛出一个异常对象(这个异常对象可能是自己实例化或者抛出已存在的);
    • throws:在方法的声明上使用,表示此方法在调用时必须处理异常。

    检查型异常(Checked Exception)与非检查型异常(Unchecked Exception)区别?

    • 所有的检查性异常都继承自java.lang.Exception;所有的非检查性异常都继承自java.lang.RuntimeEx ception。
    • 检查性异常和非检查性异常最主要的区别在于其处理异常的方式:检查性异常必须使用try catch或者throws等关键字进行处理,否则编译器会报错;非检查性异常一般是程序代码写的不够严谨而导致的问题,可以通过修改代码来规避。
    • 常见的运行时异常:空指针异常(NullPointerException)、除零异常(ArithmeticException)、数组越界异常(ArrayIndexOutOfBoundsException)等;
    • 常见的检查性异常:输入输出异常(IOException)、文件不存在异常(FileNotFoundException)、SQL语句异常(SQLException)等。

    assert关键字(了解)

    在Java中,assert关键字是从JAVA SE 1.4 引入的,为了避免和老版本的Java代码中使用了assert关键字导致错误,Java在执行的时候默认是不启动断言检查的(这个时候,所有的断言语句都 将忽略!),如果要开启断言检查,则需要用开关-enableassertions或-ea来开启。

    assert关键字语法很简单,有两种用法:

    1. assert <boolean表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出AssertionError,并终止执行。
    2. assert <boolean表达式> : <错误信息表达式>
      如果<boolean表达式>为true,则程序继续执行。
      如果为false,则程序抛出java.lang.AssertionError,并输入<错误信息表达式>。

    例如:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 10:"a不等于10";
    		System.out.println("a="+a);
    	}
    }

     执行结果为:

    public class Test {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 2;
    		assert a == 20:"a不等于20";
    		System.out.println("a="+a);
    	}
    }

    执行结果为:

    四、自定义异常

    在 Java 中你可以自定义异常。如果要自定义异常类,则扩展Exception类即可,因此这样的自定义异常都属于检查异常(checked exception)。如果要自定义非检查异常,则扩展自RuntimeException。

    按照国际惯例,自定义的异常应该总是包含如下的构造函数:

    • 一个无参构造函数
    • 一个带有String参数的构造函数,并传递给父类的构造函数。
    • 一个带有String参数和Throwable参数,并都传递给父类构造函数
    • 一个带有Throwable 参数的构造函数,并传递给父类的构造函数。

    下面是IOException类的完整源代码,可以借鉴。

    package java.io;
    
    public class IOException extends Exception {
        static final long serialVersionUID = 7818375828146090155L;
    
        public IOException() {
    	super();
        }
    
        public IOException(String message) {
    	super(message);
        }
    
        public IOException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public IOException(Throwable cause) {
            super(cause);
        }
    }
    

    finally块和return

    • 首先一个不容易理解的事实:在 try块中即便有return,break,continue等改变执行流的语句,finally也会执行。
    • finally中的return 会覆盖 try 或者catch中的返回值。
    • finally中的return或异常会抑制(消灭)前面try或者catch块中的异常。
    展开全文
  • java-深入篇-java的异常处理

    万次阅读 2017-05-10 23:04:37
    或许大家都试过这样的一种经历:不管是玩手机还是电脑,在运行一个软件的时候,有时候会无端端的崩溃掉。这种情况在就连qq在早期的时候也会发生。当然,不仅是他,就连我们使用的系统,也会有这种情况。...

    或许大家都试过这样的一种经历:不管是玩手机还是电脑,在运行一个软件的时候,有时候会无端端的崩溃掉。这种情况在就连qq在早期的时候也会发生。当然,不仅是他,就连我们使用的系统,也会有这种情况。比如windows就比较喜欢弹出一个提交错误信息报告,告诉你程序哪里有问题了,要重启。你按下确定键后,他就帮你重新启动,你要是按了其他,他就直接退出了。这要是在平时倒没什么,但是如果你在玩游戏玩到刺激的时候忽然挂掉的话,那才叫心痛啊是吧。当然,没有什么程序是不会出问题的,作为开发者,我们应该做的就是尽力去避免出现bug,以免影响用户对软件的体验度。同时,一旦出现了错误,我们也应该尽快去进行修复,而基于这一原则,就诞生我们今天的主角——java的异常处理。

    什么叫异常处理

    java中的异常处理是基于面向对象的一种运行态错误处理机制,通过对异常信息的封装实现对用户非法操作、参数设置异常、硬件系统异常,运行时网络状态更换等在运行态中可能出现的异常信息的处理机制。

    异常处理机制的体系结构

    前面说到异常处理是基于面向对象而实现的,也即是说java把大部分可能存在的异常信息都封装成一个个对应的类了。当然,我们也可以在原有类的基础上进行拓展。这就涉及了异常处理机制的体系结构:
    * 继承结构

      Throwable
        |- Error      系统级错误
        |- Exception  可修复的异常
            |- 其他Exception
            |- RuntimeException
                |- NullPointerException
                |- ArrayIndexOutOfBoundsException
                |- ArithmeticException
                |- NumberFormatException
                |- ClassCastException
                |- InputMismatchException
                ...
    

    在异常处理机制中,为了方便对异常信息进行跟踪,一般设定异常信息的内容如下:

      错误信息:
            *)类型名称
            *)提示消息
            *)行号
    

    案例说明:

    package testabstractclass;
    
    import java.io.IOException;
    public class Test1 {
    
        public static void main(String[] args) throws IOException{
            int i = 1;
            i = i/0;
            System.out.println(i);
        }
    }

    运行该程序,报错如下:

    这里写图片描述
    你看,这是一个用整数去除以0时,系统报出的异常。在这里我们就可以清晰地看到这个异常是什么意思,并且该异常出现的位置都已经显示出来了,如此我们就可以直接在代码中定位到该位置并且对错误进行修改,这就是异常处理机制最大的好处:跟踪错误代码。并且,还有一个比较重要的好处,就是对于一些可修复的程序来说,我们可以直接捕获到这个异常,并且直接修改修复它,从而避免了系统崩溃的发生。同样的例子,我们进行修改如下:

    package testabstractclass;
    
    import java.io.IOException;
    public class Test1 {
    
        public static void main(String[] args) throws IOException{
            int i = 1;
            try {
                i = i/0;
            } catch (Exception e) {
                i += 1;
            }
    
            System.out.println(i);
        }
    }

    运行结果,你会惊喜地发现,最后打印出来的是2,而不是报错。这就是因为我们在程序中捕获到了这个异常并且做出了相应的修改。那么,由我们的代码便引出了下面的一个问题:

    如何捕获异常:

    在java中,捕获异常的格式可以简述为下面这样:

    try{
    可能发生异常的代码块
    }catch(可以捕获的异常1){
    处理异常1的代码
    }catch(可以捕获的异常2){
    处理异常2的代码
    }finally{
    处理完所有异常后一定会执行的代码。
    在这里注意的事。如果在这里没有出现异常,最终也会执行这行代码
    }
    

    注意,在这里,格式是可以发生变化的,我们可以增加catch块,也可以不需要finally块。但是我们总不能说因为可以省略就可以不说吧,因此在这里便列出了一个相对完善的包含所有异常关键字的格式,它的流程如下:至于其他的格式,你们可以根据这个来参考实现:
    这里写图片描述

    如何处理异常的两种方式

    在上面的代码中,我们实现了如何检测代码异常以及处理这个异常。但是对于一些异常来说,是难以实际去修复的,那怎么办呢?常见的一个方法是:编写一个异常处理类,当我们捕获到任何异常时,都将其进行统一的处理,比如在软件上线时,我们不可能一个一个用户说:哦,你这里出现了这个问题,我给你修复了,你用我修复的这个吧。要是这样的话,铁定会把开发者给累死啊,怎么办呢?我们就把说有用户出现的错误信息集中发到开发者的邮箱,然后开发者进行修改,测试没问题之后,就对外公布说:我们的版本升级了,更好玩哦,快来更新吧!你看,这就是为什么我们要更新的好处啦。好,下面干货走起,以android中处理错误信息为例,请看:

    /**
     * 同一处理异常
     * @author 明立
     *
     */
    //Throwable是所有异常的父类,这里使用的技术就是多态了
        public static void handleException(Throwable mThrowable){
    
            StringWriter stringWriter = new StringWriter();
            PrintWriter printWriter = new PrintWriter(stringWriter);
    
            mThrowable.printStackTrace(printWriter);
            String throwableinfo = stringWriter.toString();
            //isRelease,版本标志符
            //true:上线版本
            //false:开发版本
            if (isRelease) {
            //将异常信息发送至服务器,由服务器发邮件给开发者
            }else {
            //在Log上打印错误信息
            }
        }
    }

    当然,还有一种情况,即当我们还没捕获到异常的时候,程序就已经崩溃了,那怎么办,聪明的程序员老大哥们已经想好了处理办法,即重写一个类继承UncaughtExceptionHandler方法捕获异常并提示用户并在两秒后重启应用,这就避免了你崩溃后用户直接把你删掉的结局。干货如下:

    /**
     * 程序异常crach时处理类(自动重启)
     * @author 明立
     *
     */
    public class CrachHandler implements UncaughtExceptionHandler {
        //程序的Application实现类,声明周期为应用创建到应用彻底销毁
        private CApplication mApplication;
    
        public CrachHandler(CApplication mApplication) {
            super();
            new Thread().start();
            this.mApplication = mApplication;
        }
    
        @Override
        public void uncaughtException(Thread thread, Throwable throwable) {
            // 用上面的ExceptionHandle类联网发送错误信息
            ExceptionHandle.handleException(throwable);
    
        //出现自动重启
            new Thread(){
                public void run() {
                    Looper.prepare();
                    Toast.makeText(mApplication, "程序出错,自动重启", Toast.LENGTH_SHORT).show();
                    Looper.loop();
                };}.start();
    
                try {
                    Thread.sleep(2000);
                } catch (Exception e) {
                    ExceptionHandle.handleException(e);
                }
                //两秒后自动重启软件,用peddingIntent实现
                Intent intent = new Intent(mApplication,MainActivity.class);
                PendingIntent pendingIntent = PendingIntent.getActivity(mApplication, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);
                AlarmManager alarmManager = (AlarmManager) mApplication.getSystemService(Context.ALARM_SERVICE);
                alarmManager.set(alarmManager.RTC, System.currentTimeMillis()+2000, pendingIntent);
                mApplication.exit();
        }
    
    }

    当然,在这里将Android可能有点超纲了,但实际未然,因为我们介绍完java深入知识点之后,就会正式接触到Android开发,而期间在各方面可能都会使用到异常,因此在此粘出来,以来让大家看看Android和Java之间的联系。二来也可以让大家提前掌握这个知识点。而如果说想要深入去理解何为异常处理机制的话,可以参见这篇博客(真的是写得非常详细,极力推荐):
    java提高篇-java异常处理

    下一篇:Java的多线程实现,敬请期待:
    如果对文章有疑问,可在下方评论指出,共同探讨~

    展开全文
  • 异常(Exception) 什么是 Exception ...Exception Hander是那些当异常发生时处理这些异常的代码。java和javascript都用try/catch来处理异常。 1. Exceptions in java exception在java里也是个o...

    java里的异常处理(Exception)

    Exception 是在程序执行过程中发生的一些不希望发生的事情,这些事情如果不被好好处理,就会导致奇怪的结果或者是程序终结。Exception Handler是那些当异常发生时处理这些异常的代码。所以这里只讲三个事儿:

    1. 什么是异常(Exception)

    Exception 是在程序执行过程中发生的一些不希望发生的事情,这些事情如果不被好好处理,就会导致奇怪的结果或者是程序终结。Exception Hander是那些当异常发生时处理这些异常的代码。java和javascript都用try/catch来处理异常。

    1.1 Exceptions in java

    exception在java里也是个object。
    来个图先

    Exception hierarchy
    图片来源: http://voyager.deanza.edu/~hso/cis35a/lecture/java13/intro/hier.html
    它爸爸是Throwable(面试会考,敲黑板)。它还有个兄弟叫Error

    error and exception的不同:

    An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.

    The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch.

    1.2 checked 和 unchecked的异常

    • Checked exception 是编译的时候就要求被handle的。编译的时候会检测Checked exception如果发生了有没有被handler(有没有加handler)所以也被称为compile-time exception。如果一个class是 Exception的孩子但不是 RuntimeException的孩子,那么它就是checked,写代码的时候被要求加handler 。如果用IDE, 会在写代码时要求handle这类异常。
      • 例如: CloneNotSupportedException, IOException, SQLException,
        InterruptedException, FileNotFoundException
    • Unchecked exception 也被称为runtime exception因为它发生在程序执行时。我们可以添加handler去处理这类异常,也可以不加handler不处理这类异常。如果一个class是 RuntimeException的子孙,那它就是一个unchecked exception。
      • 例如: IllegalMonitorStateException,
        ConcurrentModificationException, NullPointerException,
        IndexOutOfBoundException, NumberFormatException

    1.3 error和unchecked exception的不同

    虽然都发生在runtime,但是error不被建议去handle。 大部分情况下即使是加了catch也无法修复。而RuntimeException可以去handle。

    2. 如何处理异常 (how to handle exception)

    有一些方法在声明的时候就声明扔出一个exception。如果这个exception是checked exception,则调用这个方法的时候就必须handle它。
    checked exception就像一个炸弹,如果说方法A的某处扔出一个炸弹,或者从别处接到一个炸弹(调用了另一个扔出exception的方法), 有两种解决方案:

    • 自己把它拆了( try-catch-finally)。 这样的话调用方法A的方法不用担心这个炸弹(异常)了
    • 继续丢出去, 谁调用方法A谁来处理(在A的method declaration的时候加上throws.)

    如果采用第一种方案,当方法B调用方法A的时候,方法A已经把炸弹拆了,方法B不用担心任何事情
    如果采用第二种方法,方法B调用方法A的时候知道同时要接到一个炸弹,于是它有两种解决方案,拆了,或者继续throws。

    2.1 如何拆炸弹 用try-catch-finally

    try-catch:

    一个常见的数组越界exception。是个unchecked的exception,因为编译时没有要求handle,所以是个常见的新手 runtime异常。(不要求被handle,但是如果想handle也是可以的。)

    import java.io.*;
    public class ExceptionTest1 {
       public static void main(String args[]) {
          try {
             int a[] = new int[2];
             System.out.println(a[3]); //数组越界访问
          } catch (ArrayIndexOutOfBoundsException e) {
             System.out.println(e);//虽然没有做有意义的事情,但是阻止了程序死在半截。
          }
          System.out.println("run successfully");
       }
    }
    

    一个try可以跟着好几个catch, 为了分开处理不同的错误:

    try {
       //doing something
    } catch (Exception1 e) {
    	// handle the first type exception
        System.out.println("Exception1 happened")
    } catch (Exception2 f){
    	// handle the first type exception
        System.out.println("Exception2 happened")
    }
    

    一个exception发生之后,如果是Exception1类型的,就会被第一个handle,如果不是Exception1类型的就会接着往下找catch,如果是Exception2类型的,就会被第二个catch块handle。
    如果Exception1和Exception2是父子关系,则儿子要先被检测,因为如果爸爸先被检测,就永远也到不了儿子那个catch块了。

    finally block:

    finally block 是无论如何也会发生的一个block。 catch里的代码如果不发生异常就不会被执行,但是finally里面的代码无论如何都会执行。(除非是在try或者catch里面用System.exit(1)结束jvm。)通常用来关闭文件。

          try {
             //doing something
          } catch (Exception e) {
          	//handle the exception
          }finally {
             //一定会被执行的代码。
          }
       }
    }
    

    另外, try-finally也是合法的。

    2.2 如何继续甩锅 throws exception

    throws关键词

    //m1抛出了一个异常
    void m1 throws FileNotFoundException(){
    	//大概是想读一些文件,又不想考虑如果文件找不到咋整。(甩锅)
    }
    //m2调用了m1,相当于从m1手里接到了这个异常,自己不处理,继续往外甩。
    void m2 throws FileNotFoundException(){
    	m1();//想用m1方法,m1声明如果想用我就要考虑文件找不到的情况。
    	//但是m2依然不想考虑文件找不到咋整。
    }
    

    来看个综合的例子:

    下面代码由于接到了exception没有正确handle而产生编译错误:

    import java.io.File;
    import java.io.FileReader;
    //会有编译错误
    public class ReadFileTest {
       public static void main(String args[]) {
          getFile();
       }
       public static void getFile(){
       	   File file = new File("file.txt");
           FileReader fr = new FileReader(file);//error: unreported exception FileNotFoundException; must be caught or declared to be thrown
       }
    }
    

    因为FileReader的constructor throws了一个异常

    public FileReader(String fileName) throws FileNotFoundException
    

    所以当getFile方法调用FileReader的时候必须handle这个异常。

    下面是一个例子用上面两种方法处理异常:

    import java.io.File;
    import java.io.FileReader;
    import java.io.FileNotFoundException;
    public class ReadFileTest {
       public static void main(String args[]) {
       		getFile1();
       		System.out.println("=============");
            try{
               // 因为getFile2又把exception甩出来了,所以main方法得处理它。
               getFile2();
            }catch(FileNotFoundException e){
               System.out.println("Exception handled in main");
            }
          
       }
       //getFile1选择了自己处理,不麻烦调用它的方法
       public static void getFile1() {
    		try{
       	   		File file = new File("file.txt");
           		FileReader fr = new FileReader(file);
           	}catch(FileNotFoundException e){
           		System.out.println("Exception handled in getfile1");
           }
       }
       //getFile2选择了不处理,继续throws
       public static void getFile2() throws FileNotFoundException{
       	   File file = new File("file.txt");
           FileReader fr = new FileReader(file);
       }
    }
    

    运行结果:

    Exception handled in getfile1
    =============
    Exception handled in main
    

    一般来讲,所有的exception到了main方法这里都应该已经被解决了。如果,main方法也不负责任的往外扔。。。

    import java.io.File;
    import java.io.FileReader;
    import java.io.FileNotFoundException;
    public class ReadFileTest {
       public static void main(String args[]) throws FileNotFoundException{
       		getFile1();
       		System.out.println("=============");
            getFile2();
          
       }
       public static void getFile1() {
    		try{
       	   		File file = new File("file.txt");
           		FileReader fr = new FileReader(file);
           	}catch(FileNotFoundException e){
           		System.out.println("Exception handled in getfile1");
           }
       }
       public static void getFile2() throws FileNotFoundException{
       	   File file = new File("file.txt");
           FileReader fr = new FileReader(file);
       }
    }
    

    这样做是可以的。。。在没有文件的情况下(触发exception)运行结果:

    Exception handled in getfile1
    =============
    Exception in thread "main" java.io.FileNotFoundException: file.txt (No such file or directory)
    	at java.io.FileInputStream.open0(Native Method)
    	at java.io.FileInputStream.open(FileInputStream.java:195)
    	at java.io.FileInputStream.<init>(FileInputStream.java:138)
    	at java.io.FileReader.<init>(FileReader.java:72)
    	at ReadFileTest.getFile2(ReadFileTest.java:21)
    	at ReadFileTest.main(ReadFileTest.java:8)
    

    3.如何应用custom的exception

    3.1 如何创建一个custom的exception类

    extends exception和它的孩子们呀

    1. class New1Exception extends Exception { } // 创建一个checked exception
    2. class NewException extends IOExcpetion { } // 创建一个跟IO相关的exception
    3. class NewException extends RuntimeException { } // 创建一 UnChecked exception
    

    来个例子(就是这么简单):

    import java.io.*;
    class MyException extends Exception 
    { 
        public MyException(String s) 
        { 
            super("a MyException happens: " + s); 
            //还可以做一些其他的事
        } 
    } 
    

    3.2 如何甩出(throw)一个custom的exception

    throw 和throws

    throw是在方法或者代码块里面,用来扔炸弹 抛出异常。
    throws是在方法声明的时候,说明这个方法抛出了异常。

    用刚才的MyException写个例子:

    import java.io.*;
    public class Main 
    { 
        public static void main(String args[]) 
        { 
            try { 
                throwTest();
            } catch (MyException e) { 
                System.out.println("Caught something"); 
                System.out.println(e.getMessage()); 
            } 
            //throwTest2是一个正常的方法,扔的exception被自己handle了。
            throwTest2();
            //另用一个block测试test3,
            //如果写在同一个block,throwTest()抛出异常后,throwTest3()不会被执行
            try { 
                throwTest3();
            } catch (MyException e) { 
                System.out.println("Caught something"); 
                System.out.println(e.getMessage()); 
            } 
        } 
        // 自己不handle,扔出来之后继续在方法声明里告诉调用自己的方法需要handle
        public static void throwTest() throws MyException {
            throw new MyException("something"); 
        }
        //自己handle了,变成一个正常的方法
        public static void throwTest2() {
            try {
                throw new MyException("somethingElse"); 
            } catch (MyException e) {
                System.out.println("Caught somethingElse"); 
                System.out.println(e.getMessage()); 
            } 
        }
        //自己handle了,在catch里继续往外扔。
        public static void throwTest3() throws MyException{
            try {
                throw new MyException("somethingElse2"); 
            } catch (MyException e) {
               //一个非常不负责任的catch,但是是合法的。
               throw e;
            }
        }
    }  
    

    输出:

    Caught something
    a MyException happens: something
    Caught somethingElse
    a MyException happens: somethingElse
    Caught something
    a MyException happens: somethingElse2
    
    展开全文
  • 异常处理~

    2020-09-24 18:36:06
    异常体系结构 java.lang.Throwable java.lang.Error 、 java.lang.Exception java.lang.Exption: 编译时异常 (checked): IOException ClassN
  • 异常处理

    2019-10-30 20:04:32
    一:错误处理:在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时...
  • 前端错误收集以及统一异常处理

    千次阅读 2019-06-11 11:19:28
    代码是很难真正意义的完全按照开发者的想法运行的,意外情况总是层出不穷,放任不管显然不是一个合格的开发者该做的事情,错误信息该如何进行处理、收集以及分析显得尤为重要,这篇文章就对于这部分内容进行讨论。...
  • urllib 的异常错误处理(总结)

    千次阅读 2019-05-18 15:57:29
    在我们用 urlopen 或 opener.open 方法发出一个请求时,如果 urlopen 或 opener.open 不能处理这个 response,就产生错误。 这里主要说的是 URLError 和 HTTPError,以及对它们的错误处理。 一、URLError ...
  • 全局异常处理与统一异常处理A not always so popular but for the end user enormously important topic is the interception of errors. Even if an application has been thoroughly tested before deployment, it...
  • 编程思想 之「异常及错误处理

    千次阅读 2018-03-10 20:05:43
    在 Java 的异常及错误处理机制中,用Throwable这个类来表示可以作为异常被抛出的类。Throwable对象可以细分为两种类型(指从Throwable继承而得到的类型),分别为: Error ,表示编译时和系统错误; Exception,表...
  • java异常分类和处理

    万次阅读 2018-03-08 14:57:37
    -------------------------------------java异常分类和处理--------------------------------异常 异常都是以Exception结尾的。 在我们写程序的时候难免会出现错误,java中的异常机制为了提高我们程序的健壮性和...
  • # 异常 不可预见的 # 当程序遇到问题时,不让程序结束,而让程序越过错误,继续向下执行 # eg:print(3/0) """ except 英 [ɪkˈsept] 美 [ɪkˈsept] prep. (用于所言不包括的人或事物前)除…之外 conj. 除了;...
  • 数据预处理之异常处理

    万次阅读 2017-08-09 19:53:51
    异常值,即在数据集中存在不合理的值,又称离群点。比如年龄为-1,笔记本电脑重量为1吨等,都属于异常值的范围。从集合角度来看,异常值即离群点
  • 【SpringMVC学习07】SpringMVC中的统一异常处理

    万次阅读 多人点赞 2018-08-21 16:15:07
    在开发中,不管是dao层、service层还是controller层,都有可能抛出异常,在springmvc中,能将所有类型的异常处理从各处理过程解耦出来,既保证了相关处理过程的功能较单一,也实现了异常信息的统一处理和维
  • Java异常的几种处理方式

    万次阅读 2018-08-28 21:30:03
    Java的异常处理机制包含4,5中处理方式,今天我们来谈谈这几种方式的实现: 1)try...catch...分为单catch与多catch处理方式,其本质执行方法基本相同: 2)try...catch...finally: 3)自动关闭资源的try语句:...
  • Java异常类型及处理

    万次阅读 多人点赞 2018-09-21 10:54:18
    但是对于具体怎么分类的,JVM对其怎么处理的,代码中怎么处理的,应该怎么使用,底层怎么实现的等等,可能就会有些不是那么清晰。本文基于此详细捋一下异常类型,实现以及使用时应怎么注意。 一、异常实现及分类 1...
  • 如何解决未经处理的win32异常

    万次阅读 2014-04-03 14:23:54
    如何解决未经处理的win32异常
  • Java检查异常和非检查异常区别

    万次阅读 2017-04-08 16:26:24
    原文地址:http://yangshen998.iteye.com/blog/1311682 检查异常和未检查异常不同之处 Java代码  public class ExceptionTypeTest {   public void doSomething()throws ArithmeticException{
  • Java异常体系结构

    万次阅读 多人点赞 2011-03-25 09:24:00
    本文主要讲授的是Java语言的异常处理。Java语言的异常处理框架, 是Java语言健壮性的一个重要体现。 Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类。 在Java API中已经定义了许多...
  • 出现上图错误提示,问题基本是图片路径的问题。应将程序相应的图像放置在工程目录下(和cpp源文件同一目录下)。
1 2 3 4 5 ... 20
收藏数 1,324,749
精华内容 529,899
关键字:

异常处理