精华内容
下载资源
问答
  • (特别是,在创建异常时记录堆栈跟踪,而不是在抛出异常时记录,因此重新抛出的异常仍将具有原始堆栈跟踪).通常,人们因此使用更简单的习语.这并不是说重新抛出没有它的用​​途.例如,如果您想处理除FooBarExceptions...

    两个代码示例之间的行为没有区别. (特别是,在创建异常时记录堆栈跟踪,而不是在抛出异常时记录,因此重新抛出的异常仍将具有原始堆栈跟踪).通常,人们因此使用更简单的习语.

    这并不是说重新抛出没有它的用​​途.例如,如果您想处理除FooBarExceptions之外的所有异常,您可以编写:

    try {

    // bad code

    } catch (FooBarException e) {

    throw e;

    } catch (Exception e) {

    e.printStackTrace();

    }

    或者,如果处理异常的决定比简单地检查它的类型更复杂,那么你可以简单地捕获它,如果事实证明你无法处理它,则重新抛出:

    for (int attempts = 0; attemps < 6; attempts++) {

    try {

    return crankyMethod();

    } catch (Exception e) {

    if (fatal(e)) {

    throw e;

    } else {

    // try again

    continue;

    }

    }

    }

    值得注意的是,当人们说重新抛出时,有些人意味着抛出不同的异常,如下例所示:

    for (int i = 0; i < array.length; i++) {

    try {

    process(array[i]);

    } catch (Exception e) {

    throw new RuntimeException("Could not process element at index " + i, e);

    }

    }

    此模式的优点是使用可能相关的其他信息来装饰原始异常(在上面的示例中:无法处理哪些数据).请注意,原始异常将传递给新构造函数的构造函数,因此其堆栈跟踪不会丢失.

    展开全文
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;【1】捕获异常相关1.1)如果某个异常发生的时候没有再任何地方进行捕获, 那程序就...

    【0】README

    0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——捕获异常+再次抛出异常与异常链 的相关知识;

    【1】捕获异常相关

    1.1)如果某个异常发生的时候没有再任何地方进行捕获, 那程序就会运行终止: 并在控制台上打印出异常信息 , 其中包括异常的类型堆栈的内容;

    1.2)要想捕获一个异常, 必须设置 try/catch 语句块:

    1.2.1)如果在try语句块中抛出了一个在 catch子句中声明的异常类, 那么case1)程序将跳过try 语句块的其余代码;

    case2)程序将执行 catch 子句中 的处理器代码;

    1.2.2)如果在try语句块中没有抛出任何异常, 那么程序将跳过 catch子句;

    1.2.3)如果方法中的任何代码抛出了一个在 catch 子句中没有声明的异常类型, 那么这个方法就会立刻退出;

    1.3)看个荔枝: (看一个读取文本的程序代码以演示捕获异常的处理过程)

    public void read(String filename)

    {

    try

    {

    InputStream in = new FileInputStream(filename); // 创建输入流

    int b;

    while((b=in.read()) != -1)

    process input

    }

    catch(IOException exception)

    {

    exception.printStackTrace(); // 打印栈轨迹;

    }

    }

    对上述代码的分析(Analysis):

    A1)需要注意的是, try 语句中的大多数代码都很容易理解, 读取并处理文本行, 直到遇到文件结束符为止;(read 方法可能抛出一个IOException异常)

    A2)在这种情况下, 将跳出整个while循环, 进入 catch子句, 并生成一个 栈轨迹;

    1.4)对于一个普通 的程序来说, 处理以上的对异常处理的方法外,还有其他方法吗?

    1.4.1)通常, 最好的选择是: 什么也不做, 而是将异常传递给调用者;如果read方法出现了错误, 那就让read方法的调用者去处理。

    1.4.2)如果采用这种方式, 就必须声明这个方法可能抛出一个 IOException(将异常传递给调用者);

    public void read(String filename) throws IOException

    {

    InputStream in = new FileInputStream(filename); // 创建输入流

    int b;

    while((b=in.read()) != -1)

    process input

    }

    Attention)编译器严格地执行 throws 说明符。 如果调用了一个抛出已检查异常的方法, 就必须对它进行处理, 或者将它继续进行传递;

    1.5)对于以上两种处理异常的方法, 哪种 方法更好呢?(method1:自己处理(在可能发生异常的函数中添加try/catch 语句块);method2:将异常传递(throw)给调用者,调用者处理)

    1.5.1)通常, 应该捕获那些知道如何处理的异常, 而将那些不知道怎么处理的异常继续进行传递;如果想传递一个异常, 就必须在方法的首部添加一个throws 说明符, 以便告知调用者这个方法可能会抛出异常;

    1.5.2)阅读API后, 以便知道这个方法可能会抛出哪种异常, 然后再决定是自己处理, 还是添加到 throws 列表中;

    Attention)以上规则有个例外: 前面提到, 如果编写一个 覆盖超类的方法, 而这个方法又没有抛出异常, 那么这个方法就必须捕获方法代码中出现的每一个已检查异常。不允许在子类的 throws 说明符中出现超过超类方法所列出的异常类范围;(也就是说父类方法没有抛出异常,你子类方法也不准抛出异常,只能自己添加 try/catch 语句块自己处理)

    【2】捕获多个异常

    2.1)在一个try 语句块中可以捕获多个异常, 并对不同类型的异常做出不同的处理。可以按照下列方式为每个异常类型使用一个单独的 catch 子句;

    try

    {}

    catch(FileNotFoundException e)

    {}

    catch(UnknownHostException e)

    {}

    catch(IOException e)

    {}

    2.2)要想获得异常对象 的更多信息: 可以试着使用 e.getMessage() 得到详细的错误信息, 或者使用 e.getClass().getName(); 得到异常对象 的实际类型;

    2.3)合并catch 子句: 在 java SE7中, 同一个 catch 子句中可以捕获多个异常类型。 例如, 假设对应缺少文件和 未知主机异常的动作是一样的, 就可以合并catch 子句:

    try

    {}

    catch(FileNotFoundException | UnknownHostException e)

    {}

    catch(IOException e)

    {}

    Attention)

    A1)只有当捕获的异常类型彼此间不存在子类关系时 才需要这个特性;

    A2)捕获多个异常时, 异常变量隐含为 final变量。例如, 不能在以下子句体中为 e 赋不同的 值;

    catch(FileNotFoundException || UnknownHostException e) {}

    A3)捕获多个异常不仅会让你的代码看起来简单, 还会更高效。生成的字节码只包含一个对应公共catch 子句的代码块;

    【3】再次抛出异常与异常链

    3.1)在catch子句中可以抛出一个异常, 这样做的目的是 改变异常类型;

    3.1.1)看个荔枝:

    try

    {}

    catch(SQLException e)

    {

    throw new ServletException("data error : " + e.getMessage());

    }

    对以上代码的分析(Analysis):

    A1)这里, ServletException 用带有异常信息文本的构造器来构造;

    A2)不过, 可以有一种更好的方法, 并且将原始异常设置为新异常的原因:

    try

    {}

    catch(SQLException e)

    {

    Throwable se = new ServletException("database error");

    se.initCause(e);

    throw se;

    }

    A3)当捕获到这个异常时, 就可以使用下面的语句重新得到 原始异常:

    Throwable e = se.getCause();

    Attention)强烈建议使用这种包装技术, 这样可以让用户抛出子系统中的高级异常, 而不会丢失原始异常的小细节; (推荐使用 strongly recommended)

    Hint)

    H1)如果在一个方法中发生了一个已检查异常,而不允许抛出它, 那么包装技术就十分有用。 我们还可以捕获这个已检查异常, 并将它包装成一个 运行时异常;

    H2)有时候, 你可能只想记录一个异常,再将它重新抛出, 而不做任何改变:

    try

    {

    access the database

    }

    catch(Exception e)

    {

    logger.log(level, message, e);

    throw e;

    }

    H3)在Java SE7 之前, 将上述代码放入下述方法中, 会出现一个问题;

    public void updateRecord() throws SQLException

    因为, java 编译器查看catch 块中的 throw 语句, 然后查看e的类型, 会指出这个方法可以抛出任何Exception而不仅仅是 SQLException;

    H4)java se 7之后(编译器检测语法合法): 编译器会跟踪到 e 来自于try块中, 假设这个 try 块中仅有 的已检查异常 是 SQLException实例, 另外,假设e在catch块中未改变, 将外围方法声明为 throws SQLException 就是合法的;

    展开全文
  • 在可能会出现exception的地方,要使用try-catch或者throws或者两者都...如果希望外部知道,则在catch到之后把exception直接抛出或者抛出自定义的exception。一、异常的种类java异常可以分成两大类:Exception和Run...

    在可能会出现exception的地方,要使用try-catch或者throws或者两者都要。我的判断依据是:如果对可能出现的exception不想被外部(方法的调用者)知道,就在方法内部try-catch掉这个exception;如果希望外部知道,则在catch到之后把exception直接抛出或者抛出自定义的exception。

    一、异常的种类

    java异常可以分成两大类:Exception和RuntimeException(虽然RuntimeException是从Exception继承的)。exception异常代表“无法避免的异常” 如io异常   往往这类异常是由于外部原因造成的,程序本身无法保证他们不发生,所以这类异常必须捕获。如果在函数内部无法处理这个异常必须再次抛出(在函数后面用throws语句),如果什么都不做就出现编译错误。

    runtimexception是指“可以避免的异常”,如 null引用异常,这类异常都是由程序内部原因造成的,是可以避免的。对于这类异常可以忽略他们,但一旦发生程序就会异常终止。这类异常对debug非常有帮助,当然,如果需要也可以catch。

    另外,有些地方即使不会有exception,但是从商业逻辑上是错误的、非预期的,也可以抛出user exception。例如,用户输入非法,bank account非法透支等等。

    二、主要原则

    处理意外的一个重要原则,就是要么处理,要么接着抛,决不能吃掉(You either handle it, or throw it. You don’t eat it.)这就是说,当你捕获一个异常之后,必须决定是否立即处理这个异常,或者继续抛出这个异常(或者另一个自定义异常),以便由调用的客户端捕获之。当客户端捕获到以后,又会继续进行类似的判断。

    一般来说,GUI端是要处理异常的,比如JSP捕获到异常之后,需要先是给用户一个友好的出错信息,而不要给出系统的出错信息。系统的出错信息一方面不太友好,另一方面提供了太多的系统信息,容易被恶意用户用来攻击系统。

    换句话说,所有的异常最终必须有一个终极的处理者,这就是GUI。至于中间的环节,比如在服务器端运行的JavaBean是否要处理捕获到的异常,还是继续抛出所捕获的异常,需要视具体情况处理。

    除非你想把异常处理的责任交给调用者,一般不用throws。 比如你要读入一些文件,如果你想通知调用者,让调用者决定如何处理这个异常,你就把这个异常throws给调用者;如果你知道应该如何处理这个异常,或者你想把异常马上解决,你可以就地catch她。

    这完全取决于你想把异常自己立即处理还是想把处理责任返回给调用者。取决于你的程序的结构和要求。

    需要注意的有:

    1、如果无法处理某个异常,那就不要捕获它。

    2、如果捕获了一个异常,请不要胡乱处理它。

    3、尽量在靠近异常被抛出的地方捕获异常。

    4、在捕获异常的地方将它记录到日志中,除非您打算将它重新抛出。

    5、按照您的异常处理必须多精细来构造您的方法。

    6、需要用几种类型的异常就用几种,尤其是对于应用程序异常。

    三、异常嵌套和捕获适当的异常

    按照Java语言的定义,所谓异常(Exception)指的就是向调用方法(calling method)表示发生非正常情况的习惯方式。下面讨论两种在处理异常时可兹利用的技术:异常嵌套和捕获适当的异常。

    异常嵌套

    你在试图捕获异常并打算扔出异常时该采取什么措施呢?同时,你希望原始的异常信息可用吗?

    要回答以上的问题你不妨尝试一下NestedException类。具体的编程并不难,唯一要做的无非是利用构造器并且重载printStackTrace()以便显示出正确的数据。

    此外,你还应当考虑封装Throwable而非Exception类来创建更具有重用性的组件。之后,你可以创建NestedRuntimeException变量封装Throwable但无需对其进行声明。

    捕获适当的异常

    正确地处理异常并不是一项轻松的任务,这是因为异常的处理有时会导致程序出现其他不明行为。不过,以下三条规则可以帮助你避免错误处理异常所可能遭遇的风险。

    规则 #1: 总是捕获扔出异常的类型而不要理睬异常的超类。 为了遵守通常的代码习惯,你可以采用Exception类的大写字母作为变量名,如下所示:

    catch(FileNotFoundException fnfe)

    以及

    catch(SQLException sqle)

    规则 # 2: 决不让catch块留空。在很多情况下虽然确实编写了try/catch块但在代码的catch部分却什么都没有做。或者,如果采用了日志API(Logging API),那么请编写代码把异常写到日志中。

    规则 # 3: 决不扔出Exception基类的实例。开发人员应当总是扔出自己创建的异常类。

    扔出异常的API很难处理。在声明方法扔出java.lang.Exception的情况下,所有的问题都会强加在API用户的头上,这样他们就无法以一种专业的编程方式来处理异常。通过为扔出API声明Exception类的子类这一举措,API开发人员就可以减轻用户的负担。

    以上提到的两种技术在处理异常时还可能用得更好、更适当。嵌套技术令异常扔到另一异常的内部,而捕获适当的异常令程序调试大大简化。

    展开全文
  • 也可能是程序可能出现无法预料的异常,比如你要从一个文件读信息,可这个文件不存在,程序无法运行下去了,故程序要抓这些异常,通过异常处理机制来抛出这些异常,程序员就可以通过抛出异常来修改代码。...

    异常通常指,你的代码可能在编译时没有错误,可是运行时会出现异常。比如常见的空指针异常。也可能是程序可能出现无法预料的异常,比如你要从一个文件读信息,可这个文件不存在,程序无法运行下去了,故程序要抓这些异常,通过异常处理机制来抛出这些异常,程序员就可以通过抛出的异常来修改代码。try{}catch{}finally{}try块中放入可能会出现异常的代码,catch块负责捕获异常,finally块负责处理一些必须执行的代码,比较关闭流等。

    抛出异常:如果程序中出现了异常,没有办法将具体的异常打印出来,不做任何处理

    捕获异常:如果程序出现了异常,就能够详细的打印是什么原因导致了异常并且能够做出相应的处理,能够显示详细的Log

    如果代码是抛出异常的方式,在运行时出现异常,并且打印的Log不明显,可以改用try{}catch方式来捕获异常,打印出详细的信息

    throws语句

    throws总是出现在一个函数头中,用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说,Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException, 或它们的子类,这个规则不起作用, 因为这在程序的正常部分中是不期待出现的。 如果你想明确地抛出一个RuntimeException,你必须用throws语句来声明它的类型。

    throw语句

    throw总是出现在函数体中,用来抛出一个异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼java编译器要求java程序必须捕获或声明所有的非运行时异常,但对运行时异常可以不做处理。虽然编译器对运行时异常不强制要求处理,但是实际开发中为了程序的健壮性,还是...
  • I've been reading up more on exceptions, but I am not sure with what cases we should either throw a methodpublic void fxml() throws IOException{// method body here}or catch an exception within a metho...
  • 本文实例讲述了Python 异常的捕获、异常的传递主动抛出异常操作。分享给大家供大家参考,具体如下:异常的捕获demo.py(异常的捕获):try:# 提示用户输入一个整数num = int(input("输入一个整数:"))# 使用 8 除以...
  • 在可能会出现exception的地方,要使用try-catch或者throws或者两者都...如果希望外部知道,则在catch到之后把exception直接抛出或者抛出自定义的exception。一、异常的种类java异常可以分成两大类:Exception和Run...
  • ​ 1)异常抛出: throws 把异常抛出到上一层,谁调用谁解决 ​ 2)异常捕获: try … catch try{ 有可能出现异常的代码; }catch(FileNotFoundException e){ 处理异常代码; }catch(NullPointerException e){ 处理...
  • Java异常抛出捕获

    2021-02-28 15:08:42
    异常.pngError:一般是指虚拟机相关的问题(虚拟机错误、线程死锁等),这种错误无法回复或不可能捕获Exception:强制性要求用户必须处理RuntimeException:非检查异常,是Exception的子类,由用户选择是否进行处理...
  • 在Java中,抛出 checked 异常(Exception或其子类型 - IOException,InterruptedException等)的方法必须声明 throws 语句:public abstract int read() throws IOException;不声明 throws 语句 can't 抛出已检查异常...
  • 在写定时任务的时候, 捕获了 方法的 异常,然后出去} catch (Exception e) {logger.error("定时任务>>更新直接上级问题>>>执行任务出错了..."+e);JobExecutionException jobe = new ...
  • 我怀疑这样的事情是可能的,但是如果没有将调试器附加到java应用程序,是否可以让一些集合填充有关java应用程序中生成的每个异常的信息,无论它是否被捕获?我知道在.NET中,应用程序会生成有关异常的消息,这些异常在...
  • python如何在捕获到一个异常后再次抛出异常使用try ... except ... 可以捕获到代码中抛出的异常,在对异常进行处理后,有可能需要再次抛出这个异常,让上一级调用者继续处理,对于这样的要求,该怎样编写代码呢?...
  • 捕获异常抛出异常

    2021-08-04 00:00:05
    捕获异常抛出异常 package com.zishi.exception; public class Test { public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常:从小到大 try{ //try监控区域 System....
  • 隐式声明抛出异常 异常类型是RuntimeException类或是其子类,运行时异常,编译可通过 此类异常可以不做任何声明和处理,直接交给调用该方法的地方处理 例如:main方法中出现除零异常,但是main方法没有任何声明和...
  • } public static void main(String[] args) { /* * 抛出捕获 */ try { TryCatchTest.run(10, -1); } catch (IOException e) { e.printStackTrace(); } System.out.println("====================================...
  • 1.如果方法声明名里面有throws异常,那么方法体里面可以不抛出异常。因为可以在方法声明中包含异常说明,但实际上却不抛出!这样做的好处是,为异常先占个位置,以后就可以抛出这种异常而不用修改修改已有的代码。在...
  • 当前情况是,循环表,进行删除,如果出现表不存在,则会异常中断,导致整个存储过程挂掉,需求是要能跳过错误的执行,不进行处理,进行下个循环。最终代码:for tab_name in tables loopbeginexecut...
  • 目录标题一、捕获和处理异常二、异常抛出1. throw2. throws三、自定义异常1. 自定义异常概念2....finally{} 不管系统有没有抛出异常语句块都会执行,一般用来解放资源。除了在之前执行了system.exit(0) 异常
  • 利用throw、throws关键字抛出异常4.1 程序样例:4.2 结果说明:5.自定义异常5.1 代码样例:5.2 总结自定义类的使用方法6. 异常在实际应用中的总结经验 1.异常 1.1 什么是异常? 英文是Exception. 异常指程序运
  • 题主想知道的是怎么讲java的异常应用到实际项目中吧举个例子:场景:假设现在我们有个货物表,记录了商品名称和剩余数量其中笔(pen) 有10支.现在需要写一个业务,减少笔的数量如果笔数量不足,则通知进货大致流程注意以下...
  • 一文掌握Pyhton的异常捕获和抛出,包括Python内置异常类型、自定义异常类等。对方不想和你说话并向你抛出了一个异常。 文章目录 异常信息 捕获异常 多重异常处理 抛出异常 内置异常类型 自定义异常类型
  • 捕获异常VS抛出异常

    万次阅读 2021-02-27 14:31:12
  • 异常的产生过程解析先运行下面的程序,程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。工具类classArrayTools{//对给定的数组通过给定的角标获取元素。public ...
  • java中不捕获抛出异常发布时间:2020-06-25 14:29:16来源:亿速云阅读:137作者:Leah这期内容当中小编将会给大家带来有关java中不捕获抛出异常,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇...
  • 您应该在捕获异常方面尽可能地明确,以在特殊情况下实现良好的可追溯性。 让我们看一下handleException(...)方法,看看这种方法会发生的一些问题: 您捕获了Throwable但仅处理异常,如果发生异常,例如错误类型为...
  • Java异常处理原则之一:延迟捕获意思是,当异常发生时,不应立即捕获,而是应该考虑当前作用域是否有有能力处理这一异常的能力,如果没有,则应将该异常继续向上抛出,交由更上层的作用域来处理。一个例子:某方法...
  • Java异常抛出捕获

    2021-06-07 20:24:44
    使用throws声明抛出异常的思路是,当前方法不知道如何处理这种类型的异常,该异常应该由上级调用者处理;如果main方法也不知道如何处理这种类型的异常,也可以使用throws声明抛出异常,该异常将交给JVM处理。JVM对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 184,726
精华内容 73,890
关键字:

抛出异常与捕获异常