精华内容
下载资源
问答
  • Java存在三种可抛出结构(throwable):受检异常(checked exception)、运行时异常(runtime exception)和错误(error)。 使用原则是: 1、如果期望调用者能够恢复,则应该使用受检异常。抛出受检异常,...
    Java存在三种可抛出结构(throwable):受检异常(checked exception)、运行时异常(runtime exception)和错误(error)。

    使用原则是:

    1、如果期望调用者能够恢复,则应该使用受检异常。抛出受检异常,可以强迫调用者在一个catch子句中处理该异常,或者继续向外传播。

    2、运行时异常是指难以恢复或者不可恢复的程序错误。大多数运行时异常都是表明前提违例:precondition violation指API的调用方没有遵循调用约定

    3、错误(error)被JVM保留用于指示资源不足、约束失败或者其他程序无法继续执行的情况。最好不要实现新的Error子类,所有抛出的未受检异常都应该是RuntimeException的子类。
    展开全文
  • 1.只针对异常情况才使用异常 这里就是说不要将异常用于正常的控制流中。 ...2.java的三种可抛出结构 java语言有三种可抛出结构:受检异常、运行时异常、错误 1.受检异常就是我们平常用于ca...

    1.只针对异常情况才使用异常

    这里就是说不要将异常用于正常的控制流中

    例:

       try{.....}catch(Exception e){.......} 

    不要在抛出异常时写正常的控制代码,因为异常机制是没有jvm优化的。所以异常应该只适用于异常情况

     

    2.java的三种可抛出结构

    java语言有三种可抛出结构:受检异常、运行时异常、错误

    1.受检异常就是我们平常用于catch和throws的异常,和名字一样,有经过检查的异常。

    比如:java.io.IOException   java.sql.SQLException等等 

    2.运行时异常和错误都为未受检异常。为RuntimeException的子类

    运行时异常指API客户没有遵循API规范的约定,比如:ArrayIndexOutOfBoundsException->数组下标超出范围的异常

    错误:其它的异常错误。

    注意:不必要时,不要使用受检异常,可以用ifelse代替的,就重构trycatch异常为ifelse结构。

     

    3.抛出与抽象对应的异常

    方法抛出(trycatch)的异常有时不符合方法方面的任务,那么可以使用异常转译;

    异常转译:更高层的实现应该捕获低层的异常,同时抛出可以按照高层抽象进行解释得异常。

    下面是书中案例:

        public E get(int index) {
            try {
                return listIterator(index).next();
            } catch (NoSuchElementException exc) {
                throw new IndexOutOfBoundsException("Index: "+index);
            }
        }

    NoSunchElementException是低层的异常,IndexOutOfBoundsException是高层异常。

    这里介绍了一个特例:异常链

    异常链:低层异常被传到高层异常,高层异常提供方法(Throwable的getCause方法)来访问低层异常

            try{
               ...    //Use lower-level abstraction to do our bidding
            }cache(LowerLevelException cause){
                throw new HigherLevelException(cause);
            }

     

    展开全文
  • Java可抛出结构我们应该知道Java中Throwable是所有异常(Exception)和错误(Error)超类。首先进入Throwable类看到第一段注释:The {@code Throwable} class is the superclass of all errors and exceptions in the ...

    Java可抛出结构

    我们应该知道Java中Throwable是所有异常(Exception)和错误(Error)的超类。首先进入Throwable类看到第一段注释:

    The {@code Throwable} class is the superclass of all errors and exceptions in the Java language. Only objects that are instances of this class (or one of its subclasses) are thrown by the Java Virtual Machine or can be thrown by the Java {@code throw} statement. Similarly, only this class or one of its subclasses can be the argument type in a {@code catch} clause.

    翻译过来就是:

    {@code Throwable}类是Java语言中所有错误和异常的超类。 只有作为此类(或其子类之一)实例的对象才会被Java虚拟机抛出,或者可被Java {@code throw}语句抛出。 类似地,只有这个类或它的一个子类可以是{@code catch}子句中的参数类型。

    也就是说Java语言机制中的所有异常处理都应该直接或间接继承自Throwable类,当然也可以直接使用Throwable,但一般不建议这么用。

    Java的可抛出结构可以分为受检抛出结构和非受检抛出结构。

    • 受检抛出结构:受检抛出结构是我们日常在代码中最常使用的抛出结构,Java中受检抛出结构就是受检异常。每一个被抛出的受检异常,都应该在某个地方被捕获并处理。它强制用户来处理该异常并恢复程序。也就是说如果希望调用方能够适当地恢复,这种情况应该用受检异常。
    • 非受检抛出结构:Java中有两个非受检可抛出结构:运行时异常和错误。非受检抛出结构不需要也不应该被捕获。也就是说如果程序抛出运行时异常或者错误,程序就应该停止运行。
    3321f539d95d95d045dccacdea99778b.png

    Java抛出结构

    错误(Error)

    我们先讲Error。很多人感觉自己在代码中从未使用过Error,这是正确的。因为按照惯例Error往往被JVM保留用于表示资源不足、约束失败或其他无法继续执行的条件。所以开发者在代码中最好不要在实现任何新的Error的子类。那么我们的选择只有一个:你实现的所有非受检的抛出结构都应该是RuntimeException类或者其子类。所以在写代码时就不需要考虑Error的事情了。

    受检异常

    受检异常通俗来讲就是日常中我们在try...catch...语句中抛出或者捕获的异常。我们最常使用的受检异常是Exception(注意这个)、IOException和SQLException。当然我们也可以自定义很多受检异常。

    有些人看到下面运行时异常时会疑惑:运行时异常都继承自RuntimeException类,那是不是受检异常也应该都继承自一个类似CheckedException类?答案是否定的。我们可以进入Throwable源码看一下其注释第二段:

    For the purposes of compile-time checking of exceptions, {@code Throwable} and any subclass of {@code Throwable} that is not also a subclass of either {@link RuntimeException} or {@link Error} are regarded as checked exceptions.

    翻译过来就是:出于编译时检查异常的目的,{@code Throwable}和{@code Throwable}的任何子类(除了{@link RuntimeException}或{@link Error}类及其子类)都被视为已检查的异常。

    也就是说,虽然我们从概念上将受检异常、运行时异常和错误作为并列的三个知识点,但Java语言将除了Error和RuntimeException类及其子类外,其他所有直接或间接继承自Throwable的类都视为受检异常。

    很多人习惯直接使用Exception,方便、快捷。但我们为什么有时候要自定义受检异常呢?

    Java中一切皆对象,Exception和Error当然也不例外。Exception是对象也就意味这,我们可以在它上面定义任意的方法,实现任意的接口。不过一般我们的目的只是提供分析异常的辅助信息。Exception作为一个基础异常类,提供的信息往往少且抽象。所以我们可以实现自己的受检异常,定制行为和信息。

    定制自己的异常非常简单,简单地继承Throwable类或者Exception类,然后在构造方法中调用父类构造方法即可。但这样没有定制功能的自定义受检异常没有任何意义。可以为自定义异常类添加信息处理方法等使其变得有意义。

    运行时异常

    运行时异常不需要也不应该被我们捕获。常见的运行时异常一般有:参数非法(IllegalArgumentException)、空指针异常(NullPointerException)、下标越界(IndexOutBoundsException)等,它们都继承自RuntimeException类。

    这些异常都不陌生,在调试项目的时候遇到问题Terminal经常会报一大堆红:xxxx NullPointerException at:org.xxx.xxx 巴拉巴拉一大堆,这些就是运行时异常。

    要注意,运行时异常不应该被捕获,但并不意味着不能被捕获,在代码中把它放在catch后面或者用throw语句抛出,语法允许,不会报错。既然Throwable类且其子类都能被捕获和抛出,RuntimeException当然不例外。不过虽然代码语法不错,但从逻辑上讲,系统发生运行时异常往往不可恢复,继续执行有害无益应该终止,所以不应该捕获。

    Java泛型和通配符类型你真的能搞清楚吗

    其实Java枚举类和普通类没什么区别

    Java字符串:StringBuilder 和 StringBuffer

    展开全文
  • 1 Java 异常简介 ...其中,Error 表示系统级别严重程序错误,一般由 JVM 抛出,我们也不应该捕获这类异常,用户自定义异常一般都派生自 Exception 类。 从是否被编译器强制检查一点,异常又...

    1 Java 异常简介

            众所周知,Java 的所有异常都派生自 Throwable 类,在继承结构上,从 Throwable 派生出了 Error 和 Exception 两大类。其中,Error 表示系统级别的严重程序错误,一般由 JVM 抛出,我们也不应该捕获这类异常,用户自定义的异常一般都派生自 Exception 类。

           从是否被编译器强制检查一点,异常又可分为受检异常(Checked Exception)和未受检异常(Unchecked Exception)。未受检异常派生自 Error 或者 RuntimeException,表示不可恢复的程序错误,典型例子有 AssertionError、NullPointerException 等,编译器不会强制我们捕获这类异常。受检异常则是除了 Error/RuntimeException 之外,派生自 Throwable 或者 Exception 的其他异常,比如 IOException、SQLException 等。

           如果一个方法声明自己可能抛出受检异常,那么编译器会强制它的调用者必须使用 try-catch 捕获此异常,或者在自己的方法中加上 throws 声明将异常继续传播给外界除非抛出RuntimeException或其子类,可在外部进行异常捕获。

     

     

            多年以来,Java 中受检异常的设计一直颇受争议,反对者认为,受检异常容易破坏方法声明的兼容性,会使代码的可读性降低,还增加开发的工作量等等。当然也有一些支持者,他们认为受检异常可以强迫程序员去思考,有助于他们写出更健壮的代码,可以参考王垠的文章「Kotlin 和 Checked Exception」。

    2 java 中的异常处理实例

    直接上代码,先贴下面测试需要调用的方法:
    // catch 后续处理工作
    public static boolean catchMethod() {
        System.out.print("call catchMethod and return  --->>  ");
        return false;
    }
    // finally后续处理工作
    public static void finallyMethod() {
        System.out.println();
        System.out.print("call finallyMethod and do something  --->>  ");
    }


    1. 抛出 Exception,没有 finally,当 catch 遇上 return

    public static boolean catchTest() {
      try {
          int i = 10 / 0;   // 抛出 Exception,后续处理被拒绝
          System.out.println("i vaule is : " + i);
          return true;    // Exception 已经抛出,没有获得被执行的机会
      } catch (Exception e) {
          System.out.println(" -- Exception --");
          return catchMethod();    // Exception 抛出,获得了调用方法并返回方法值的机会
      }
    }
    后台输出结果:
    -- Exception --
    call catchMethod and return  --->>  false


    2. 抛出 Exception,当 catch 体里有 return,finally 体的代码块将在 catch 执行 return 之前被执行
    public static boolean catchFinallyTest1() {
      try {
          int i = 10 / 0; // 抛出 Exception,后续处理被拒绝
          System.out.println("i vaule is : " + i);
          return true;   // Exception 已经抛出,没有获得被执行的机会
      } catch (Exception e) {
          System.out.println(" -- Exception --");
          return catchMethod();  // Exception 抛出,获得了调用方法的机会,但方法值在 finally 执行完后才返回
      }finally{
        finallyMethod();  // Exception 抛出,finally 代码块将在 catch 执行 return 之前被执行
      }
    }
    后台输出结果:

     -- Exception --
    call catchMethod and return  --->>  
    call finallyMethod and do something  --->>  false

    3. 不抛 Exception,当 finally 代码块里面遇上 return,finally 执行完后将结束整个方法

    public static boolean catchFinallyTest2() {
        try {
            int i = 10 / 2;  // 不抛出 Exception
            System.out.println("i vaule is : " + i);
            return true;   // 获得被执行的机会,但执行需要在 finally 执行完成之后才能被执行
        } catch (Exception e) {
            System.out.println(" -- Exception --");
            return catchMethod();
        }finally{
            finallyMethod();
            return false; // finally 中含有 return 语句,这个 return 将结束这个方法,不会在执行完之后再跳回 try 或 catch 继续执行,方法到此结束,返回 false
        }
    }


    后台输出结果:
    i vaule is : 5
    call finallyMethod and do something  --->>  false


    4. 不抛 Exception,当 finally 代码块里面遇上 System.exit() 方法 将结束和终止整个程序,而不只是方法

    public static boolean finallyExitTest() {
        try {
            int i = 10 / 2;  // 不抛出 Exception
            System.out.println("i vaule is : " + i);
            return true;   // 获得被执行的机会,但由于 finally 已经终止程序,返回值没有机会被返回
        } catch (Exception e) {
            System.out.println(" -- Exception --");
            return true;
        }finally {
            finallyMethod();
            System.exit(0);// finally 中含有 System.exit() 语句,System.exit() 将退出整个程序,程序将被终止
        }
    }


    后台输出结果:
    i vaule is : 5
    call finallyMethod and do something  --->>  


    5. 抛出 Exception,当 catch 和 finally 同时遇上 return,catch 的 return 返回值将不会被返回,finally 的 return 语句将结束整个方法并返回

    public static boolean finallyTest1() {
        try {
            int i = 10 / 0; // 抛出 Exception,后续处理被拒绝
            System.out.println("i vaule is : " + i);
            return true;   // Exception 已经抛出,没有获得被执行的机会
        } catch (Exception e) {
            System.out.println(" -- Exception --");
            return true;  // Exception 已经抛出,获得被执行的机会,但返回操作将被 finally 截断
        }finally {
            finallyMethod();
            return false;  // return 将结束整个方法,返回 false
        }
    }


    后台输出结果:
     -- Exception --
    call finallyMethod and do something  --->>  false


    6. 不抛出 Exception,当 finally 遇上 return,try 的 return 返回值将不会被返回,finally 的 return 语句将结束整个方法并返回

    public static boolean finallyTest2() {
        try {
            int i = 10 / 2;  // 不抛出 Exception
            System.out.println("i vaule is : " + i);
            return true;   // 获得被执行的机会,但返回将被 finally 截断
        } catch (Exception e) {
            System.out.println(" -- Exception --");
            return true;
        }finally {
            finallyMethod();
            return false; // return 将结束这个方法,不会在执行完之后再跳回 try 或 catch 继续执行,返回 false
        }
    }
    后台输出结果:
    i vaule is : 5
    call finallyMethod and do something  --->>  false


    结语:

    java 的异常处理中(假设方法需要返回值):

    1. 在不抛出异常的情况下,程序执行完 try 里面的代码块之后,该方法并不会立即结束,而是继续试图去寻找该方法有没有 finally 的代码块,
    2. 如果没有 finally 代码块,整个方法在执行完 try 代码块后返回相应的值来结束整个方法;
    3. 如果有 finally 代码块,此时程序执行到 try 代码块里的 return 语句之时并不会立即执行 return,而是先去执行 finally 代码块里的代码,
    4. 若 finally 代码块里没有 return 或没有能够终止程序的代码,程序将在执行完 finally 代码块代码之后再返回 try 代码块执行 return 语句来结束整个方法;
    5. 若 finally 代码块里有 return 或含有能够终止程序的代码,方法将在执行完 finally 之后被结束,不再跳回 try 代码块执行 return。

    在抛出异常的情况下,原理也是和上面的一样的,你把上面说到的 try 换成 catch 去理解就 OK 了 *_*

     

    ###################

    java异常处理-finally中使用return和throw语句

    java异常语句中的finally块通常用来做资源释放操作,如关闭文件、关闭网络连接、关闭数据库连接等。正常情况下finally语句中不应该使用return语句也不应该抛出异常,以下讨论仅限于java语言设计本身,正常编码时应避免。

    finally块中使用return会覆盖method的返回值

    以下代码的返回值为:1

    public static int div(){
            try {
                return 3;
            }catch (ArithmeticException e){
                System.out.println("catch in div");
                return 2;
            }
            finally {
                System.out.println("finally in div");
                return 1;
            }
        }

     

    以下代码的返回值同样是:1

     public static int div(){
            try {
                return 3/0;
            }catch (ArithmeticException e){
                System.out.println("catch in div");
                return 2;
            }
            finally {
                System.out.println("finally in div");
                return 1;
            }
        }

     

    finally块中使用return会抑制异常的冒泡传输

    即:只要finally中使用了return语句,调用者便认为该方法正常返回

    以下代码

    /**
     * Created by Administrator on 2017/11/27.
     */
    
    public class Test {
    
        public static void main(String[] args) {
            adapter();
        }
    
        public static void adapter() {
            try {
                div();
            } catch (ArithmeticException e) {
                System.out.println("catch in adapter");
            } finally {
                System.out.println("finally in adapter");
            }
        }
    
        public static int div() {
            try {
                int a = 5 / 0;
                return a;
            } catch (ArithmeticException e) {
                System.out.println("catch in div");
                throw e;  // 重新将异常抛出给调用者
            } finally {
                System.out.println("finally in div");
            }
        }
    }

    输出为

    catch in div
    finally in div
    catch in adapter
    finally in adapter

     

     但如果在 div 的finally块中添加了return语句

        public static int div(){
            try {
                int a =  5/0;
                return a;
            }catch (ArithmeticException e){
                System.out.println("catch in div");
                throw  e; // 重新将异常抛出给调用者,但是抛出会被忽略
            }
            finally {
                System.out.println("finally in div");
                return 1;
            }
        }

    则代码的输出为

    catch in div
    finally in div
    finally in adapter

    即:finally块中的return语句会阻止异常的栈调用传输,使caller认为该方法已经正常返回

     

    finally块中的throw语句会覆盖try和catch语句中的异常

    以下代码

    /**
     * Created by Administrator on 2017/11/27.
     */
    
    public class Test {
    
        public static void main(String[] args) {
            adapter();
        }
    
        public static void adapter() {
            try {
                div();
            } catch (Exception e) {
                System.out.println(String.format("catch in adapter: %s",e.getMessage()));
            } finally {
                System.out.println("finally in adapter");
            }
        }
    
        public static int div() throws Exception{
            try {
                int a = 5 / 0;
                return a;
            } catch (ArithmeticException e) {
                System.out.println("catch in div");
                throw new Exception("Exception in div"); // 抛出新的异常
            } finally {
                System.out.println("finally in div");
                throw new Exception("Exception in Finally");  // 抛出新的异常
            }
        }
    }

    输出是:

    catch in div
    finally in div
    catch in adapter: Exception in Finally
    finally in adapter

    即,catch块中抛出的异常北finally块抛出的异常替换了

     

    修改div方法为

     public static int div() throws Exception{
            try {
                int a = 5 / 0;
                return a;
            }  finally {
                System.out.println("finally in div");
                throw new Exception("Exception in Finally");  // 抛出新的异常
            }
        }

    输出为:

    finally in div
    catch in adapter: Exception in Finally
    finally in adapter

    即,try块中捕获的异常北finally块抛出的异常替换

     

    finally块和普通代码块一样,无法同时使用return语句和throw语句,因为无法通过编译

    展开全文
  • 即使任何人处理程序意图表示可能在Throwable类型层次结构之外东西,该想法也会失败,因为今天类文件必须具有包含异常处理程序方法StackMapTable,并且StackMapTable将引用任何可抛出的作为java.lang实例....
  • Vector与ArrayList,两者唯一差别是:vector自带线程互斥,多个线程对其读写会抛出异常,而arraylist则允许多个线程读写,其他部分是一模一样,换句话说,如果是单线程在读写,使用Vector与ArrayList没有任何...
  • java异常层次结构

    2018-03-25 17:59:16
    RunTimeException为运行时异常 java编译器不检查 手动 用try检查或者用throw抛出 除RunTimeExecption和Error类异常 其余异常和其子类都属于检查异常 若出现检查异常 编译器将 强制要你处理 或者抛出 */...
  • Java可抛出(Throwable)的结构分为三种类型:被检查异常(CheckedException),运行时异常 (RuntimeException),错误(Error)。 1、运行时异常 定义:RuntimeException及其子类都被称为运行时异常。 特点:Java编译器...
  • java 数据结构队列

    2018-04-05 15:53:22
    offer()/add()均执行入栈操作,它们区别是,当超出队列界限时候,add()会直接抛出异常等你处理,而offer()有事先判断所以放回false pop()/remove()方法都是从队列中删除第一个元素,区别是,队列...
  • Java异常层次结构

    2017-07-21 20:33:00
    1. 如果是不可查异常(unchecked exception),即Error、...2. 必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句...
  • –1、异常继承结构 Throwable - 顶级父类 – Error:系统错误,无法修复 – Exception:修复错误 –RunTimeException –ClassCastException –ClassNotFoundException --2、测试 package com.xsd.exception; ...
  • Java 中,所有异常都有一个共同祖先 Throwable(可抛出),Throwable: 有两个重要子类:Exception(异常)和 Error(错误) 二、Java异常分类 如上图,Java异常可分为两类:错误Error和异常Exception,...
  • java中,程序运行过程中产生问题叫做异常,在java中所有程序运行产生问题都可以用一个类来表示,这个类叫做它Throwable,它有两个子类 ... throw关键字,可以手动的抛出一个异常对象。 格式: throw new...
  • Java存储结构-JVM规范学习笔记

    千次阅读 2010-09-06 19:07:00
    Java 存储结构-JVM规范学习笔记Java线程每个Java虚拟机线程具有一个私有,与线程同时创建的Java栈,同时每个线程还拥有一个属于...如果栈是动态分配,当视图扩展Java栈但没有足够存储器来实现时,将抛出OutOf
  • Java的异常

    2020-02-16 16:57:46
    文章目录Java的异常一、只针对异常的情况才使用异常二、对可恢复的情况使用受检异常,对于编程错误使用运行时异常2.1 使用受检异常还是未受检异常2.2 有两种未受检的可抛出结构:运行时异常和错误2.3 运行时异常2.4 ...
  •     Throwable是Java所有异常或错误父类,意思是可抛出的。Throwable包含了Error和Exception两部分,分别表示错误和异常。其中Exception异常包括运行时异常(RuntimeException)和非运行时异常,也称之为不...
  • 运行时异常和错误都是不需要也不应该被捕获的可抛出结构。如果程序抛出运行时异常或者错误,说明出现了不可恢复的情形,继续执行下去有害无益。如果没有捕捉到这样的结构,将会导致当前线程停止,并出现适当的错误...
  • 本地方法栈本地方法栈特点为什么要使用...如果线程请求分配栈容量超过本地方法栈允许最大容量,Java虚拟机就会抛出StackOverFlowError异常。 如果可以动态扩展,并且在扩展时无法申请足够内存,或者在创建线程
  • 作者 | 武培轩责编 | 屠敏出品 | CSDN 博客异常处理是 Java 开发中一个重要部分,是为了处理任何...Java 编程语言也允许创建新自定义异常,并通过使用 throw 和 throws关键字抛出它们。在Java编程中,Java ...
  • 本文将会从以下几个方面介绍java异常机制:异常机制层次结构异常处理过程抛出异常捕获异常异常机制实现细节一、异常机制层次结构java程序设计语言中,所有异常对象都是派生于Throwable类,一般情况下...
  • JAVA_API1.6文档(中文)

    万次下载 热门讨论 2010-04-12 13:31:34
    javax.transaction 包含解组期间通过 ORB 机制抛出的三个异常。 javax.transaction.xa 提供定义事务管理器和资源管理器之间协定 API,它允许事务管理器添加或删除 JTA 事务中资源对象(由资源管理器驱动程序...
  • java异常

    2021-03-16 19:29:19
      Object下有Throwable(可抛出的)   Throwable下有两个分支:Error(不可处理,直接退出JVM)和Exception(可处理)   Exception下有两个分支:    Exception直接子类:编译时异常(要求在编写程序...
  • 异常 EXception 异常是指在程序的运行过程中所发生的不正常的事件,它会中断正在运行的程序,由Java应用程序抛出和处理的非严重错误 异常分为Checked异常和运行时异常 Checked异常必须捕获或者声明抛出 ...Java的异常
  • Java可抛出(Throwable)的结构分为三种类型:被检查异常(CheckedException),运行时异常(RuntimeException),错误(Error)。 运行时异常:RuntimeException及其子类都被称为运行时异常。 特点:Java编译器不会检查...
  • java异常机制

    2018-03-01 13:41:23
    java异常 异常指不期而至各种状况,如:文件找不到,网络连接失败,非法参数等。异常是个事件,它发生在程序运行期间,干扰了正常指令...在Java中,所有异常都有个共同祖先Throwable(可抛出)。 Thro...
  • 打开jdkAPI文档,随便找一个类,例如:空值异常NullPointerException,它继承结构如下图所示:接下来我们看看异常继承结构,如下图:Throwable继承Object类,Throable代表所有异常都是可抛出的,并且它有两个...
  • Java可抛出的(Throwable)的结构分为三类: 运行时异常(RuntimeException) Java编译器不会检查它。需人为避免处理。Java中明确规定,对于此类异常可以有选择地进行处理,若没有处理,交给JVM默认进行处理。 ...
  • 如果对正在被迭代集合进行结构改变(即对该集合使用add、remove或clear方法),那么迭代器就不再合法(并且在其后使用该迭代器将会有ConcurrentModificationException异常被抛出).如果使用迭代器自己remove方法...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 363
精华内容 145
关键字:

java的可抛出结构

java 订阅