AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java：如何处理异常

2017-11-17 1169
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
在处理异常时，应该区分 checked 异常和 unchecked 异常。对于 checked 异常，我们应该提供健壮的异常恢复机制，而对于 unchecked 异常，这就是编程错误即 bug ，应该在调试阶段很好的发现和处理它们。
1. Java 异常层次结构

上图（注：该图引自 [url]http://dev2dev.bea.com.cn/techdoc/200702364792.html[/url] ）标出了 Java 异常层次结构，也指出了哪些异常是 unchecked ，哪些异常是 checked 。下面给出几段常见的异常处理代理，试图总结日常开发中应该如何处理异常。
2. 针对 checked 异常的恢复机制
checked 异常并不是编程错误，它的出现是软件运行阶段所不可避免的。最常见的这类异常如 socket 连接超时。
对于此类异常，我们应该在程序的运行态下试图从异常中恢复过来。下面这段代码 (Recover.java) 的主要逻辑是，对目标值 protected   int   current 进行判断，如果该值大于 2 则成功，否则抛出 NotBigEnoughException 异常。
在执行程序的过程中，在每次 catch 到 NotBigEnoughException 异常时，我们对 current 值递增，试图从异常中恢复过来。
NotBigEnoughException.java
package  com.zj.exception.types;
 
public   class  NotBigEnoughException  extends  Exception {
     public  NotBigEnoughException() {
        super ();
    }
 
     public  NotBigEnoughException(String msg) {
        super (msg);
    }
}
 
Recover.java
package  com.zj.exception;
import  com.zj.exception.types.NotBigEnoughException;
 
public   class  Recover {
     protected   int   current  = 0;
     protected   boolean   accept  =  false ;
 
     public  Recover() {}
 
     public  Recover( int  cur) {
        current  = cur;
    }
 
     public   void  increment() {
       ++ current ;
    }
 
     public   boolean  passed() {
        return   accept ;
    }
 
     public   void  passing()  throws  NotBigEnoughException {
        if  ( current  > 2) {
            accept  =  true ;
           System. out .println( "accept "  +  current );
       }  else
            throw   new  NotBigEnoughException( "reject "  +  current );
    }
 
     public   static   void  main(String[] args) {
       Recover re =  new  Recover();
        while  (!re.passed()) {
            try  {
              re.passing();
           }  catch  (NotBigEnoughException e) {
              System. out .println(e);
              re.increment();
           }
       }
    }
}
结果：
com.zj.exception.types.NotBigEnoughException : reject 0
com.zj.exception.types.NotBigEnoughException : reject 1
com.zj.exception.types.NotBigEnoughException : reject 2
accept 3
3. 继承异常
在子类继承父类的情况下，子类 override 方法的异常声明只能取自（小于等于）父类该方法的异常声明；对于子类构造方法的异常声明必须包含（大于等于）父类构造方法的异常声明。
类 Inheritor 继承自类 Recover ， 它的方法 passing() 试图声明一个父类没有的异常 UnknowException ， 这样做是不允许的。
UnknowException.java
package  com.zj.exception.types;
 
public   class  UnknowException  extends  Exception {
     public  UnknowException() {
        super ();
    }
 
     public  UnknowException(String msg) {
        super (msg);
    }
}
error in:  Inheritor.java
//couldn't throws new exceptions where not found in its base class
public   void  passing()  throws  NotBigEnoughException, UnknowException {
     if  ( current  > 2) {
        accept  =  true ;
       System. out .println( "accept "  +  current );
    }  else   if  ( current  >= 0)
        throw   new  NotBigEnoughException( "reject "  +  current );
     else
        throw   new  UnknowException( "i don't know how to deal with "
              +  current );
}
之所以覆盖这个方法的目的是对父类的 passing() 方法做进一步扩展，对 0<=current<=2 的情况抛出 NotBigEnoughException ， 而对 current<0 的情况则抛出一个新的异常 UnknowException 。
此时，提供两种解决方法。
方法一，使用恢复异常机制， overrding passing （）方法，这样可以处理掉所有的异常，因此不需要异常声明。
ok in:  Inheritor.java
//sure passing(),so not have to throw exceptions
public   void  passing(){
     while  (!passed()) {
        try  {
            super .passing();
       }  catch  (NotBigEnoughException e) {
           increment();
       }
    }
}
方法二，写一个加强的 passing （）方法，即 fortifiedPassing() ， 对于在父类 passing （）中捕获的异常，进行再判断。如果是 0<=current<=2 的情况则重新抛出 NotBigEnoughException ，如果是 current<0 的情况则抛出一个新的异常 UnknowException 。
ok in:  Inheritor.java
public   void  fortifiedPassing()  throws  NotBigEnoughException, UnknowException{
     try  {
        super .passing();
    }  catch  (NotBigEnoughException e) {
        if ( current >=0)
            throw  e;
        else
            throw   new  UnknowException( "i don't know how to deal with "
                  +  current );
    }
}
 
Inheritor.java
package  com.zj.exception;
import  com.zj.exception.types.NotBigEnoughException;
import  com.zj.exception.types.UnknowException;
 
public   class  Inheritor  extends  Recover {
     public  Inheritor( int  cur) {
        super (cur);
    }
 
     //couldn't throws new exceptions where not found in its base class
     /**
     public   void   passing()   throws   NotBigEnoughException,   UnknowException {
        if   (current   >   2)   {
            accept   =   true;
            System.out.println("accept   "   +   current);
        }   else   if   (current   >=   0)
            throw   new   NotBigEnoughException("reject   "   +   current);
        else
            throw   new   UnknowException("i   don't   know   how   to   deal   with   "
                   +   current);
     }*/
   
     //sure passing(),so not have to throw exceptions
     public   void  passing(){
        while  (!passed()) {
            try  {
               super .passing();
           }  catch  (NotBigEnoughException e) {
              increment();
           }
       }
    }
   
     public   void  fortifiedPassing()  throws  NotBigEnoughException, UnknowException{
        try  {
            super .passing();
       }  catch  (NotBigEnoughException e) {
            if ( current >=0)
               throw  e;
            else
               throw   new  UnknowException( "i don't know how to deal with "
                     +  current );
       }
    }
 
     public   static   void  main(String[] args) {
        // not required try-catch
        new  Inheritor(3).passing();
        new  Inheritor(1).passing();
        new  Inheritor(-1).passing();   
        //no exceptions
        try  {
            new  Inheritor(3).fortifiedPassing();
       }  catch  (NotBigEnoughException e) {
           e.printStackTrace();
       }  catch  (UnknowException e) {
           System. out .println(e);
       }
        //NotBigEnoughException:
        try  {
            new  Inheritor(1).fortifiedPassing();
       }  catch  (NotBigEnoughException e) {
           e.printStackTrace();
       }  catch  (UnknowException e) {
           System. out .println(e);
       }
        //UnknownException:
        try  {
            new  Inheritor(-1).fortifiedPassing();
       }  catch  (NotBigEnoughException e) {
           e.printStackTrace();
       }  catch  (UnknowException e) {
           System. out .println(e);
       }
    }
}
结果：
accept 3
accept 3
accept 3
accept 3
com.zj.exception.types.UnknowException : i don't know how to deal with -1
com.zj.exception.types.NotBigEnoughException : reject 1
    at com.zj.exception.Recover.passing( Recover.java:28 )
    at com.zj.exception.Inheritor.fortifiedPassing( Inheritor.java:38 )
    at com.zj.exception.Inheritor.main( Inheritor.java:63 )
4.RuntimeException 与包装异常
RuntimeException 是 unhecked 异常，它们由 JVM 抛出（你也可以抛出它），并且不必在异常声明（ throws ）中列出。
如果 RuntimeException 没有被 catch 而到达 mian （）方法时，那么在程序退出前会自动调用该异常的 printStackTrace() 方法，打印该异常。
RuntimeException 代表的是编程错误（如 0 除数，数组越界），是应该在调试阶段解决的。
当你在捕获某些异常，而不知道该如果处理时，你可以将它包装为 RuntimeException ，这样在后续的方法调用过程中就不用声明 (throws) 该方法了。
在类 Wrapper 中，我们 override  fortifiedPassing() 方法，并将它可能抛出的异常包装为 RuntimeException 。
Wrapper.java
package  com.zj.exception;
import  com.zj.exception.types.NotBigEnoughException;
import  com.zj.exception.types.UnknowException;
 
public   class  Wrapper  extends  Inheritor {
     public  Wrapper( int  cur) {
        super (cur);
    }
 
     public   void  fortifiedPassing() {
        try  {
            super .fortifiedPassing();
       }  catch  (NotBigEnoughException e) {
            throw   new  RuntimeException(e);
       }  catch  (UnknowException e) {
            throw   new  RuntimeException(e);
       }
    }
 
     public   static   void  main(String[] args) {
        // not required try-catch
        new  Wrapper(3).fortifiedPassing();
        new  Wrapper(1).fortifiedPassing();
        new  Wrapper(-1).fortifiedPassing();
    }
}
结果：
accept 3
Exception in thread "main"  java.lang.RuntimeException :  com.zj.exception.types.NotBigEnoughException : reject 1
    at com.zj.exception.Wrapper.fortifiedPassing( Wrapper.java:14 )
    at com.zj.exception.Wrapper.main( Wrapper.java:23 )
Caused by:  com.zj.exception.types.NotBigEnoughException : reject 1
    at com.zj.exception.Recover.passing( Recover.java:28 )
    at com.zj.exception.Inheritor.fortifiedPassing( Inheritor.java:38 )
    at com.zj.exception.Wrapper.fortifiedPassing( Wrapper.java:12 )
    ... 1 more


本文转自zhangjunhd51CTO博客，原文链接：http://blog.51cto.com/zhangjunhd/70681，如需转载请自行联系原作者
文章标签：
Java
关键词：
Java异常
Java如何处理
Java如何处理异常
科技小先锋
目录
相关文章
Java开发者
|
10月前
|
Java
在 Java 中捕获和处理自定义异常的代码示例
本文提供了一个 Java 代码示例，展示了如何捕获和处理自定义异常。通过创建自定义异常类并使用 try-catch 语句，可以更灵活地处理程序中的错误情况。
Java开发者
305 1
程序员小假
|
3月前
|
Java 程序员 数据库连接
我们详细地讲解一下 Java 异常及要如何处理
我是小假 期待与你的下一次相遇 ~
程序员小假
62 1
Java开发者
|
10月前
|
Java API 调度
如何避免 Java 中的 TimeoutException 异常
在Java中，`TimeoutException`通常发生在执行操作超过预设时间时。要避免此异常，可以优化代码逻辑，减少不必要的等待；合理设置超时时间，确保其足够完成正常操作；使用异步处理或线程池管理任务，提高程序响应性。
Java开发者
493 13
Java开发者
|
10月前
|
Java
在 Java 中，如何自定义`NumberFormatException`异常
在Java中，自定义`NumberFormatException`异常可以通过继承`IllegalArgumentException`类并重写其构造方法来实现。自定义异常类可以添加额外的错误信息或行为，以便更精确地处理特定的数字格式转换错误。
Java开发者
172 1
游客kufrkwrbkmpsa
|
6月前
|
SQL Java 中间件
【YashanDB知识库】yasdb jdbc驱动集成BeetISQL中间件，业务(java)报autoAssignKey failure异常
在BeetISQL 2.13.8版本中，客户使用batch insert向yashandb表插入数据并尝试获取自动生成的sequence id时，出现类型转换异常。原因是beetlsql在prepareStatement时未指定返回列，导致yashan JDBC驱动返回rowid（字符串），与Java Bean中的数字类型tid不匹配。此问题影响业务流程，使无法正确获取sequence id。解决方法包括：1) 在batchInsert时不返回自动生成的sequence id；2) 升级至BeetISQL 3，其已修正该问题。
游客kufrkwrbkmpsa
111 1
【YashanDB知识库】yasdb jdbc驱动集成BeetISQL中间件，业务(java)报autoAssignKey failure异常
游客kufrkwrbkmpsa
|
6月前
|
SQL druid Oracle
【YashanDB知识库】yasdb jdbc驱动集成druid连接池，业务(java)日志中有token IDENTIFIER start异常
客户Java日志中出现异常，影响Druid的merge SQL功能（将SQL字面量替换为绑定变量以统计性能），但不影响正常业务流程。原因是Druid在merge SQL时传入null作为dbType，导致无法解析递归查询中的`start`关键字。
游客kufrkwrbkmpsa
154 3
软件求生
|
7月前
|
Java 程序员 开发者
Java社招面试题：一个线程运行时发生异常会怎样？
大家好，我是小米。今天分享一个经典的 Java 面试题：线程运行时发生异常，程序会怎样处理？此问题考察 Java 线程和异常处理机制的理解。线程发生异常，默认会导致线程终止，但可以通过 try-catch 捕获并处理，避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理，不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制，为面试做好准备。如果你觉得有帮助，欢迎收藏、转发！
软件求生
464 14
卓伊凡
|
7月前
|
缓存 Java 应用服务中间件
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
卓伊凡
1261 5
Java开发者
|
10月前
|
IDE 前端开发 Java
怎样避免 Java 中的 NoSuchFieldError 异常
在Java中避免NoSuchFieldError异常的关键在于确保类路径下没有不同版本的类文件冲突，避免反射时使用不存在的字段，以及确保所有依赖库版本兼容。编译和运行时使用的类版本应保持一致。
Java开发者
328 8
Java开发者
|
10月前
|
Java 编译器
如何避免在 Java 中出现 NoSuchElementException 异常
在Java中，`NoSuchElementException`通常发生在使用迭代器、枚举或流等遍历集合时，尝试访问不存在的元素。为了避免该异常，可以在访问前检查是否有下一个元素（如使用`hasNext()`方法），或者使用`Optional`类处理可能为空的情况。正确管理集合边界和条件判断是关键。
Java开发者
285 6

热门文章

最新文章

  • 1
    Java浮点类型详解：使用与区别
  • 2
    2025 年 Java 全栈从环境搭建到项目上线实操全流程指南：Java 全栈最新实操指南（2025 版）
  • 3
    2025 Java 零基础到实战最新技术实操全攻略与学习指南
  • 4
    Java中的Lambda表达式：简化代码的利器
  • 5
    Java Stream API：现代数据处理之道
  • 6
    Java中的Switch表达式：更简洁的多路分支
  • 7
    2025 年最新 Java 学习路线图含实操指南助你高效入门 Java 编程掌握核心技能
  • 8
    Java中的Lambda表达式：简洁与功能的结合
  • 9
    零基础自学 Java 全栈必备最全学习路线及知识清单方向指引
  • 10
    Java标识符详解
  • 1
    综合案例【商品管理系统-Java基础版】（附完整源码）
    470
  • 2
    Java常见异常及对应解决办法
    172
  • 3
    19 Java8概述（Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API）
    283
  • 4
    18 Java反射reflect（类加载+获取类对象+通用操作+设计模式+枚举+注解）
    284
  • 5
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
    166
  • 6
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（中）
    176
  • 7
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（上）
    157
  • 8
    16 Java网络编程（计算机网络+网络模型OSI/TCP/IP+通信协议等）
    198
  • 9
    15 Java IO流（File类+IO流+字节流+字符流+字节编码）
    122
  • 10
    13 Java异常（异常过程解析、throw、throws、try-catch关键字）
    279

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    2025云栖大会，阿里云百炼邀请您的参与和见证