精华内容
下载资源
问答
  • java接口 异常处理实验 java实验 报告
  • java全局异常处理

    千次阅读 2018-08-21 12:43:42
    如果失败,返回错误码加上错误信息,这样就导致接口的返回值对象需要兼容正确返回和错误返回值两种情况,其实接口的返回值只需要返回你想要的对象或者列表就行了,错误信息统一交给全局异常处理搞定。 使用全...

    使用全局异常的好处是,不在需要去定义很多类型的返回值,当业务出错的时候直接通过异常的返回值方式来返回给前端或者API调用方错误信息。

    以前我们的处理方式是如果接口执行正确返回200编码加上正确的结果值,如果失败,返回错误码加上错误信息,这样就导致接口的返回值对象需要兼容正确返回和错误返回值两种情况,其实接口的返回值只需要返回你想要的对象或者列表就行了,错误信息统一交给全局异常处理搞定。

    使用全局异常类

        定义一个业务异常类,所有的业务异常都需要抛出这一个异常,然后通过不同的状态码来区分具体是哪个异常,和对应的描述信息,状态码和描述信息在全局异常类里面通过枚举去定义。

       如果类型比较多,可以定义多个枚举来区分不同类型的业务异常。

    自定义一个业务异常,然后通过枚举类型区分具体的那个业务的异常,抛出对应的错误信息

    在你业务错误的地方只需要使用throw new BusinessException()就OK了。

    public class BusinessException extends RuntimeException {
    
     private BaseResult result;
    
    
     public BusinessException() {
    
     }
    
     public BusinessException(int status, String message) {
     result = new BaseResult(status, message);
     }
    
     public BusinessException(ExceptionType exceptionType) {
     if (exceptionType != null) {
     result = new BaseResult(exceptionType.getStatus(), exceptionType.getMessage());
     }
     }
    
     public BaseResult getMessageResult() {
     return result;
     }
    
     public enum ExceptionType {
     NAME_ALREADY_EXISTED(Constants.ExceptionType.ALREADY_EXISTS, Constants.ExceptionType.NAME_ALREADY_EXISTS);
    
     private String message;
    
     private int status;
    
     ExceptionType(int status, String message) {
     this.message = message;
     this.status = status;
     }
    
     public String getMessage() {
     return message;
     }
    
     public void setMessage(String message) {
     this.message = message;
     }
    
     public int getStatus() {
     return status;
     }
    
     public void setStatus(int status) {
     this.status = status;
     }
     }
    
    }
     ConstraintViolationException是validated的一个异常,校验参数的。

    下面是一个全局异常捕获例子:

    @ControllerAdvice
    @Order(1) // Macross framework ResponseBodyExceptionHandler is 1000, we start at 900
    public class GlobalExceptionHandler {
    
     private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class);
    
    
    
     @ExceptionHandler(value = ConstraintViolationException.class)
     @ResponseBody
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     public BaseResult verifyErrorHandler(HttpServletRequest request, Exception e) {
     LOGGER.error("[exception:GlobalExceptionHandler] {} {}", request.getMethod(), request.getRequestURI());
     ConstraintViolationException ce = (ConstraintViolationException) e;
     Set<ConstraintViolation<?>> constraintViolationSet = ce.getConstraintViolations();
     StringBuilder sb = new StringBuilder();
     if (null != constraintViolationSet && !constraintViolationSet.isEmpty()) {
     for (ConstraintViolation<?> violation : constraintViolationSet) {
     sb.append(violation.getPropertyPath());
     sb.append(":");
     sb.append(violation.getMessage());
     sb.append(',');
     }
     sb.deleteCharAt(sb.length() - 1);
     }
     BaseResult result = new BaseResult(HttpStatus.INTERNAL_SERVER_ERROR.value(), sb.toString());
     LOGGER.error("[exception:GlobalExceptionHandler] parameter verify error, error message: {}", sb.toString());
     return result;
     }
    
     @ExceptionHandler(value = MethodArgumentNotValidException.class)
     @ResponseBody
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     public BaseResult verifyErrorHandlers(HttpServletRequest request, Exception e) {
     LOGGER.error("[exception:GlobalExceptionHandler] {} {}", request.getMethod(), request.getRequestURI());
     MethodArgumentNotValidException ce = (MethodArgumentNotValidException) e;
     BindingResult bindingResult = ce.getBindingResult();
     StringBuilder sb = new StringBuilder();
     if (bindingResult.hasErrors()) {
     List<FieldError> fieldErrorList = bindingResult.getFieldErrors();
     for (FieldError fieldError : fieldErrorList) {
     sb.append(fieldError.getDefaultMessage());
     sb.append(',');
     }
     sb.deleteCharAt(sb.length() - 1);
     }
     BaseResult result = new BaseResult(HttpStatus.INTERNAL_SERVER_ERROR.value(), sb.toString());
     LOGGER.error("[exception:GlobalExceptionHandler] parameter verify error, error message: {}", sb.toString());
     return result;
     }
    
     @ExceptionHandler(value = BusinessException.class)
     @ResponseBody
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     public BaseResult handlerNameAlreadyExistedException(HttpServletRequest request, Exception e) {
     LOGGER.error("[exception:NameAlreadyExistedException] {} {}", request.getMethod(), request.getRequestURI());
     BusinessException businessException = (BusinessException) e;
     BaseResult result = businessException.getMessageResult();
     LOGGER.error("[exception:NameAlreadyExistedException]controller class raise exception. e={}", e);
     return result;
     }
    
     @ExceptionHandler(value = Exception.class)
     @ResponseBody
     @ResponseStatus(HttpStatus.BAD_REQUEST)
     public BaseResult handler(HttpServletRequest request, Exception e) {
     LOGGER.error("[exception:GlobalExceptionHandler] {} {}", request.getMethod(), request.getRequestURI());
     BaseResult result = new BaseResult(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage());
     LOGGER.error("[exception:GlobalExceptionHandler]controller class raise exception. e={}", e);
     return result;
     }
    }
    展开全文
  • //设置超时时间超时异常处理 public static void main(String[] args) { final ExecutorService exec = Executors.newFixedThreadPool(1); Callable call = new Callable() { pub
    //设置超时时间超时异常处理
    		public static void main(String[] args) {
    			 final ExecutorService exec = Executors.newFixedThreadPool(1);  
    	          
    		        Callable<String> call = new Callable<String>() {  
    		            public String call() throws Exception {  
    		                //开始执行耗时操作  
    		                Thread.sleep(1000 * 5);  
    		                return "线程执行完成.";  
    		            }  
    		        };  
    		          
    		        try {  
    		            Future<String> future = exec.submit(call);  
    		            String obj = future.get(1000 * 6, TimeUnit.MILLISECONDS); //任务处理超时时间设为 1 秒  
    		            System.out.println("任务成功返回:" + obj);  
    		        } catch (Exception e) {  
    		            System.out.println("处理失败.");  
    		            e.printStackTrace();  
    		        }  
    		        // 关闭线程池  
    		        exec.shutdown();  
    		}

    展开全文
  • java异常处理

    千次阅读 2018-08-07 11:34:44
    今天在看hadoop源码时,想想自己最近在做的那个系统,发现很多异常处理的方式不对,还是按照传统的异常处理方式(即:采用返回值来标识程序出现的异常情况)。而hadoop中很多方法的声明是有异常抛出的,而我的系统中...

    转载

    原文:https://www.cnblogs.com/tsiangleo/p/4396574.html

    今天在看hadoop源码时,想想自己最近在做的那个系统,发现很多异常处理的方式不对,还是按照传统的异常处理方式(即:采用返回值来标识程序出现的异常情况)。而hadoop中很多方法的声明是有异常抛出的,而我的系统中的很多方法的声明都没有抛出异常。只是判断了异常情况,并输出了错误提示,但是并没有抛出异常。

    org.apache.hadoop.hdfs.protocol包下的Block类的readFields()方法:

    public void readFields(DataInput in) throws IOException {
        this.blockId = in.readLong();
        this.numBytes = in.readLong();
        this.generationStamp = in.readLong();
        if (numBytes < 0) {
          throw new IOException("Unexpected block size: " + numBytes);//抛出异常,要是的话就不会抛出,而只是System.out.println错误提示,
        }

    1.如果方法声明名里面有throws异常,那么方法体里面可以不抛出异常。因为可以在方法声明中包含异常说明,但实际上却不抛出!这样做的好处是,为异常先占个位置,以后就可以抛出这种异常而不用修改修改已有的代码。在定义抽象基类和接口时这种能力很重要,这样派生类或接口实现类就能够抛出这些预先声明的异常。

    2.为什么有的方法声明里面没有throws,但方法体里面却抛出了异常?从RuntimeException继承的异常,可以在没有异常说明throws的情况下被抛出!对于Runtime异常(也称为非检查的异常unchecked exception),编译器不需要异常说明。只能在代码中忽略RuntimeException(及其子类)类型的异常,其他类型的异常的处理都是由编译器强制实施的。究其原因,RuntimeException代表的是编程错误。

    3.运行时异常会被Java虚拟机自动抛出!

    《有效处理Java异常三原则》http://www.importnew.com/1701.html

    1. 异常处理基础
      1.1 System.out.println是高代价的。调用System.out.println会降低系统吞吐量。

      1.2 在生产环境中别用异常的printStackTrace()方法。printStackTrace默认会把调用的堆栈打印到控制台上,在生产环境中访问控制台是不现实的。

    2. 异常处理基本原则
      2.1 如果你不能处理异常,不要捕获该异常。

      2.2 如果要捕获,应在离异常源近的地方捕获它。

      2.3 不要吞没你捕获的异常。
      *(就是捕获的异常,但是什么也不做)

      2.4 除非你要重新抛出异常,否则把它log起来。

      2.5 当一个异常被重新包装,然后重新抛出的时候,不要打印statck trace。

      2.6 用自定义的异常类,不要每次需要抛出异常的时候都抛出java.lang.Exception。方法的调用者可以通过throws知道有哪些异常需要处理–所以它是自我描述的。

      2.7 如果你编写业务逻辑,对于终端用户无法修复的错误,系统应该抛出非检查的异常(unchecked exception);如果你编写一个第三方的包给其他的开发人员用,对于不可修复的错误要用需要检查的异常(checked exception)。

      2.8 绝对不要因为写throws语句会让你用起来不舒服,而不声明需要检查的异常。

      2.9 应用级别的错误或不可修复的系统异常用非检查的异常(unchecked exception)抛出。
      *(注意是错误,意味着不可修复,比如配置文件错误)

      2.10 根据异常的粒度组织你的方法

    其他参考文章:

    http://klyuan.iteye.com/blog/72170

    http://blog.csdn.net/luqin1988/article/details/7970792

    http://www.onjava.com/pub/a/onjava/2003/11/19/exceptions.html 对应的译文,不怎么准确:http://blog.sciencenet.cn/blog-252888-761119.html

    http://www.oschina.net/question/92866_15634

    http://www.importnew.com/1701.html

    http://sunflowers.iteye.com/blog/767175

    展开全文
  • Java基础 异常处理总结

    千次阅读 2013-10-11 19:17:03
    Java异常处理机制 6 4 如何定义和使用异常类 8 5运行时异常和受检查异常 10 5.1运行时异常 10 5.2 受检查异常 10 5.3 两者的区别 10 5.4 运行时错误 11 5.5 最佳解决方案 11 6 异常转型和异常链 12...

    1 Java异常的基础知识 1

    2 Java异常类类图 4

    3 Java异常处理机制 6

    4 如何定义和使用异常类 8

    5运行时异常和受检查异常 10

    5.1运行时异常 10

    5.2 受检查异常 10

    5.3 两者的区别 10

    5.4 运行时错误 11

    5.5 最佳解决方案 11

    6 异常转型和异常链 12

    7 Java调试常见异常汇总 14

     

    Java基础异常处理总结

    异常处理是程序设计中一个非常重要的方面,也是程序设计的一大难点,从C开始,你也许已经知道如何用if...else...来控制异常了,也许是自发的,然而这种控制异常痛苦,同一个异常或者错误如果多个地方出现,那么你每个地方都要做相同处理,感觉相当的麻烦!

      Java语言在设计的当初就考虑到这些问题,提出异常处理的框架的方案,所有的异常都可以用一个类型来表示,不同类型的异常对应不同的子类异常(这里的异常包括错误概念),定义异常处理的规范,在1.4版本以后增加了异常链机制,从而便于跟踪异常!这是Java语言设计者的高明之处,也是Java语言中的一个难点,下面是我对Java异常知识的一个总结,也算是资源回收一下。

    1 Java异常的基础知识

      异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误java.lang.Error;如果你用System.out.println(11/0),那么你是因为你用0做了除数,会抛出java.lang.ArithmeticException的异常。

      有些异常需要做处理,有些则不需要捕获处理,后面会详细讲到。

      天有不测风云,人有旦夕祸福,Java的程序代码也如此。在编程过程中,首先应当尽可能去避免错误和异常发生,对于不可避免、不可预测的情况则在考虑异常发生时如何处理。

      Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的,不同异常有不同的分类,每种异常都对应一个类型(class),每个异常都对应一个异常(类的)对象。

      异常类从哪里来?有两个来源,一是Java语言本身定义的一些基本异常类型,二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是 Throwable 的一种形式,它指出了合理的应用程序想要捕获的条件。

      异常的对象从哪里来呢?有两个来源,一是Java运行时环境自动抛出系统生成的异常,而不管你是否愿意捕获和处理,它总要被抛出!比如除数为0的异常。二是程序员自己抛出的异常,这个异常可以是程序员自己定义的,也可以是Java语言中定义的,用throw 关键字抛出异常,这种异常常用来向调用者汇报异常的一些信息。

      异常是针对方法来说的,抛出、声明抛出、捕获和处理异常都是在方法中进行的。

      Java异常处理通过5个关键字trycatchthrowthrowsfinally进行管理。基本过程是用try语句块包住要监视的语句,如果在try语句块内出现异常,则异常会被抛出,你的代码在catch语句块中可以捕获到这个异常并做处理;还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常,然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行,一般结构如下:

      try{

      程序代码

      }catch(异常类型异常的变量名1){

      程序代码

      }catch(异常类型异常的变量名2){

      程序代码

      }finally{

      程序代码

      }

      catch语句可以有多个,用来匹配多个异常,匹配上多个中一个后,执行catch语句块时候仅仅执行匹配上的异常。catch的类型是Java语言中定义的或者程序员自己定义的,表示代码抛出异常的类型,异常的变量名表示抛出异常的对象的引用,如果catch捕获并匹配上了该异常,那么就可以直接用这个异常变量名,此时该异常变量名指向所匹配的异常,并且在catch代码块中可以直接引用。这一点非常非常的特殊和重要!

      Java异常处理的目的是提高程序的健壮性,你可以在catchfinally代码块中给程序一个修正机会,使得程序不因异常而终止或者流程发生以外的改变。同时,通过获取Java异常信息,也为程序的开发维护提供了方便,一般通过异常信息就很快就能找到出现异常的问题(代码)所在。

      Java异常处理是Java语言的一大特色,也是个难点,掌握异常处理可以让写的代码更健壮和易于维护。

    2 Java异常类类图

      下面是这几个类的层次图:

      java.lang.Object

         java.lang.Throwable

          java.lang.Exception

            java.lang.RuntimeException

              java.lang.Error

               java.lang.ThreadDeath

      下面四个类的介绍来自java api 文档。

      1Throwable

      Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时,才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地,只有此类或其子类之一才可以是 catch 子句中的参数类型。

      两个子类的实例,Error  Exception,通常用于指示发生了异常情况。通常,这些实例是在异常情况的上下文中新近创建的,因此包含了相关的信息(比如堆栈跟踪数据)

      2Exception

      Exception 类及其子类是 Throwable 的一种形式,它指出了合理的应用程序想要捕获的条件,表示程序本身可以处理的异常。

      3Error

      Error  Throwable 的子类,表示仅靠程序本身无法恢复的严重错误,用于指示合理的应用程序不应该试图捕获的严重问题。

      在执行该方法期间,无需在方法中通过throws声明可能抛出但没有捕获的 Error 的任何子类,因为Java编译器不去检查它,也就是说,当程序中可能出现这类异常时,即使没有用try...catch语句捕获它,也没有用throws字句声明抛出它,还是会编译通过。

      4RuntimeException

      RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。Java编译器不去检查它,也就是说,当程序中可能出现这类异常时,即使没有用try...catch语句捕获它,也没有用throws字句声明抛出它,还是会编译通过,这种异常可以通过改进代码实现来避免。

      5ThreadDeath

      调用 Thread 类中带有零参数的 stop 方法时,受害线程将抛出一个 ThreadDeath 实例。

      仅当应用程序在被异步终止后必须清除时才应该捕获这个类的实例。如果 ThreadDeath 被一个方法捕获,那么将它重新抛出非常重要,因为这样才能让该线程真正终止。

      如果没有捕获 ThreadDeath,则顶级错误处理程序不会输出消息。

      虽然 ThreadDeath 类是正常出现的,但它只能是 Error 的子类而不是 Exception 的子类,因为许多应用程序捕获所有出现的Exception,然后又将其放弃。

      以上是对有关异常API的一个简单介绍,用法都很简单,关键在于理解异常处理的原理,具体用法参看Java API文档。

    3 Java异常处理机制

      对于可能出现异常的代码,有两种处理办法:

      第一、在方法中用try...catch语句捕获并处理异常,catach语句可以有多个,用来匹配多个异常。例如:

      

    public void p(int x){ 
      try{ 
      ... 
      }catch(Exception e){ 
      ... 
      }finally{ 
      ... 
      
      }

      第二、对于处理不了的异常或者要转型的异常,在方法的声明处通过throws语句抛出异常。例如:

      

    public void test1() throws MyException{ 
      ... 
      if(....){ 
      throw new MyException(); 
      
      }

      如果每个方法都是简单的抛出异常,那么在方法调用方法的多层嵌套调用中,Java虚拟机会从出现异常的方法代码块中往回找,直到找到处理该异常的代码块为止。然后将异常交给相应的catch语句处理。如果Java虚拟机追溯到方法调用栈最底部main()方法时,如果仍然没有找到处理异常的代码块,将按照下面的步骤处理:

      第一、调用异常的对象的printStackTrace()方法,打印方法调用栈的异常信息。

      第二、如果出现异常的线程为主线程,则整个程序运行终止;如果非主线程,则终止该线程,其他线程继续运行。

      通过分析思考可以看出,越早处理异常消耗的资源和时间越小,产生影响的范围也越小。因此,不要把自己能处理的异常也抛给调用者。

      还有一点,不可忽视:finally语句在任何情况下都必须执行的代码,这样可以保证一些在任何情况下都必须执行代码的可靠性。比如,在数据库查询异常的时候,应该释放JDBC连接等等。finally语句先于return语句执行,而不论其先后位置,也不管是否try块出现异常。finally语句唯一不被执行的情况是方法执行了System.exit()方法。System.exit()的作用是终止当前正在运行的 Java 虚拟机。finally语句块中不能通过给变量赋新值来改变return的返回值,也建议不要在finally块中使用return语句,没有意义还容易导致错误。

      最后还应该注意一下异常处理的语法规则:

      第一、try语句不能单独存在,可以和catchfinally组成 try...catch...finallytry...catchtry...finally三种结构,catch语句可以有一个或多个,finally语句最多一个,trycatchfinally这三个关键字均不能单独使用。

      第二、trycatchfinally三个代码块中变量的作用域分别独立而不能相互访问。如果要在三个块中都可以访问,则需要将变量定义到这些块的外面。

      第三、多个catch块时候,Java虚拟机会匹配其中一个异常类或其子类,就执行这个catch块,而不会再执行别的catch块。

      第四、throw语句后不允许有紧跟其他语句,因为这些没有机会执行。

      第五、如果一个方法调用了另外一个声明抛出异常的方法,那么这个方法要么处理异常,要么声明抛出。

      那怎么判断一个方法可能会出现异常呢?一般来说,方法声明的时候用了throws语句,方法中有throw语句,方法调用的方法声明有throws关键字。

      throwthrows关键字的区别

      throw用来抛出一个异常,在方法体内。语法格式为:throw 异常对象。

      throws用来声明方法可能会抛出什么异常,在方法名后,语法格式为:throws 异常类型1,异常类型2...异常类型n

    4 如何定义和使用异常类

      1、使用已有的异常类,假如为IOExceptionSQLException

     

     try{ 
      程序代码 
      }catch(IOException ioe){ 
      程序代码 
      }catch(SQLException sqle){ 
      程序代码 
      }finally{ 
      程序代码 
      }

      2、自定义异常类

      创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。例如:

     

     public class MyException extends Exception{ 
      public MyException(){} 
      public MyException(String smg){ 
      super(smg); 
      
      }

      3、使用自定义的异常

      用throws声明方法可能抛出自定义的异常,并用throw语句在适当的地方抛出自定义的异常。例如:

      在某种条件抛出异常

      public void test1() throws MyException{ 
      ... 
      if(....){ 
      throw new MyException(); 
      
      }

      将异常转型(也叫转译),使得异常更易读易于理解

     

      public void test2() throws MyException{ 
      ... 
      try{ 
      ... 
      }catch(SQLException e){ 
      ... 
      throw new MyException(); 
      
      }

      还有一个代码,很有意思:

      

    public void test2() throws MyException{ 
      ... 
      try { 
      ... 
      } catch (MyException e) { 
      throw e; 
      
      }

      这段代码实际上捕获了异常,然后又和盘托出,没有一点意义,如果这样还有什么好处理的,不处理就行了,直接在方法前用throws声明抛出不就得了。异常的捕获就要做一些有意义的处理。

    5运行时异常和受检查异常

      Exception类可以分为两种:运行时异常和受检查异常。

    5.1运行时异常

      RuntimeException类及其子类都被称为运行时异常,这种异常的特点是Java编译器不去检查它,也就是说,当程序中可能出现这类异常时,即使没有用try...catch语句捕获它,也没有用throws字句声明抛出它,还是会编译通过。例如,当除数为零时,就会抛出java.lang.ArithmeticException异常。

    5.2 受检查异常

      除了RuntimeException类及其子类外,其他的Exception类及其子类都属于受检查异常,这种异常的特点是要么用try...catch捕获处理,要么用throws语句声明抛出,否则编译不会通过。

    5.3 两者的区别

      运行时异常表示无法让程序恢复运行的异常,导致这种异常的原因通常是由于执行了错误的操作。一旦出现错误,建议让程序终止。

      受检查异常表示程序可以处理的异常。如果抛出异常的方法本身不处理或者不能处理它,那么方法的调用者就必须去处理该异常,否则调用会出错,连编译也无法通过。当然,这两种异常都是可以通过程序来捕获并处理的,比如除数为零的运行时异常:

      public class HelloWorld { 
      public static void main(String[] args) { 
      System.out.println("Hello World!!!"); 
      try{ 
      System.out.println(1/0); 
      }catch(ArithmeticException e){ 
      System.out.println("除数为0!"); 
      
      System.out.println("除数为零后程序没有终止啊,呵呵!!!"); 
      
      
      运行结果: 
      Hello World!!! 
      除数为0! 
      除数为零后程序没有终止啊,呵呵!!!

    5.4 运行时错误

      Error类及其子类表示运行时错误,通常是由Java虚拟机抛出的,JDK中与定义了一些错误类,比如VirtualMachineError

      和OutOfMemoryError,程序本身无法修复这些错误.一般不去扩展Error类来创建用户自定义的错误类。而RuntimeException类表示程序代码中的错误,是可扩展的,用户可以创建特定运行时异常类。

      Error(运行时错误)和运行时异常的相同之处是:Java编译器都不去检查它们,当程序运行时出现它们,都会终止运行。

    5.5 最佳解决方案

      对于运行时异常,我们不要用try...catch来捕获处理,而是在程序开发调试阶段,尽量去避免这种异常,一旦发现该异常,正确的做法就会改进程序设计的代码和实现方式,修改程序中的错误,从而避免这种异常。捕获并处理运行时异常是好的解决办法,因为可以通过改进代码实现来避免该种异常的发生。

      对于受检查异常,没说的,老老实实去按照异常处理的方法去处理,要么用try...catch捕获并解决,要么用throws抛出!

      对于Error(运行时错误),不需要在程序中做任何处理,出现问题后,应该在程序在外的地方找问题,然后解决。

    6 异常转型和异常链

      异常转型在上面已经提到过了,实际上就是捕获到异常后,将异常以新的类型的异常再抛出,这样做一般为了异常的信息更直观!比如:

     

     public void run() throws MyException{ 
      ... 
      try{ 
      ... 
      }catch(IOException e){ 
      ... 
      throw new MyException(); 
      }finally{ 
      ... 
      
      }

      异常链,在JDK1.4以后版本中,Throwable类支持异常链机制。Throwable 包含了其线程创建时线程执行堆栈的快照。它还包含了给出有关错误更多信息的消息字符串。最后,它还可以包含 cause(原因):另一个导致此 throwable 抛出的 throwable。它也称为异常链 设施,因为 cause 自身也会有 cause,依此类推,就形成了异常链,每个异常都是由另一个异常引起的。

    通俗的说,异常链就是把原始的异常包装为新的异常类,并在新的异常类中封装了原始异常类,这样做的目的在于找到异常的根本原因。

           try {

                f(); //有一个异常B,因为B异常catch C异常,必须初始化异常原因//c.initCause(e)才能保证B也被输出,否则只有C被抛出而抛出B的操作被终止。

     

            } catch (ExceptionB e) {

                ExceptionC c = new ExceptionC("exception c");

                //异常链

                c.initCause(e);

                throw c;

            }

    结果如下:

    log.ToFile$ExceptionC

        at log.ToFile.g(ToFile.java:49)

        at log.ToFile.main(ToFile.java:36)

    Caused by: log.ToFile$ExceptionB

        at log.ToFile.f(ToFile.java:29)

        at log.ToFile.g(ToFile.java:47)

        ... 1 more

      通过Throwable的两个构造方法可以创建自定义的包含异常原因的异常类型:

      Throwable(String message, Throwable cause)

      构造一个带指定详细消息和 cause 的新 throwable

      Throwable(Throwable cause)

      构造一个带指定 cause  (cause==null ? null :cause.toString())(它通常包含类和 cause 的详细消息)的详细消息的新 throwable

     

    7 Java调试常见异常汇总

    1. java.lang.nullpointerexception 

    这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等。对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的,所以还需要对每个元素都进行初始化(如果要调用的话)

    2. java.lang.classnotfoundexception 

    这个异常是很多原本在jb等开发环境中开发的程序员,把jb下的程序包放在wtk下编译经常出现的问题,异常的解释是"指定的类不存在",这里主要考虑一下类的名称和路径是否正确即可,如果是在jb下做的程序包,一般都是默认加上package的,所以转到wtk下后要注意把package的路径加上。

    3. java.lang.arithmeticexception 

    这个异常的解释是"数学运算异常",比如程序中出现了除以零这样的运算就会出这样的异常,对这种异常,大家就要好好检查一下自己程序中涉及到数学运算的地方,公式是不是有不妥了。

    4. java.lang.arrayindexoutofboundsexception 

    这个异常相信很多朋友也经常遇到过,异常的解释是"数组下标越界",现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。

    5. java.lang.illegalargumentexception 

    这个异常的解释是"方法的参数错误",很多j2me的类库中的方法在一些情况下都会引发这样的错误,比如音量调节方法中的音量参数如果写成负数就会出现这个异常,再比如g.setcolor(int red,int green,int blue)这个方法中的三个值,如果有超过255的也会出现这个异常,因此一旦发现这个异常,我们要做的,就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。

    6. java.lang.illegalaccessexception 

    这个异常的解释是"没有访问权限",当应用程序要调用一个类,但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。

    其他还有很多异常,我就不一一列举了,我要说明的是,一个合格的程序员,需要对程序中常见的问题有相当的了解和相应的解决办法,否则仅仅停留在写程序而不会改程序的话,会极大影响到自己的开发的。关于异常的全部说明,在api里都可以查阅。

    算术异常类:ArithmeticExecption 

    空指针异常类:NullPointerException 

    类型强制转换异常:ClassCastException 

    数组负下标异常:NegativeArrayException 

    数组下标越界异常:ArrayIndexOutOfBoundsException 

    违背安全原则异常:SecturityException 

    文件已结束异常:EOFException 

    文件未找到异常:FileNotFoundException 

    字符串转换为数字异常:NumberFormatException 

    操作数据库异常:SQLException 

    输入输出异常:IOException 

    方法未找到异常:NoSuchMethodException 

    java.lang.AbstractMethodError 

    抽象方法错误。当应用试图调用抽象方法时抛出。

    java.lang.AssertionError 

    断言错。用来指示一个断言失败的情况。

    java.lang.ClassCircularityError 

    类循环依赖错误。在初始化一个类时,若检测到类之间循环依赖则抛出该异常。

    java.lang.ClassFormatError 

    类格式错误。当Java虚拟机试图从一个文件中读取Java类,而检测到该文件的内容不符合类的有效格式时抛出。

    java.lang.Error 

    错误。是所有错误的基类,用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。

    java.lang.ExceptionInInitializerError 

    初始化程序错误。当执行一个类的静态初始化程序的过程中,发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。

    java.lang.IllegalAccessError 

    违法访问错误。当一个应用试图访问、修改某个类的域(Field)或者调用其方法,但是又违反域或方法的可见性声明,则抛出该异常。

    java.lang.IncompatibleClassChangeError 

    不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时,抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下,容易引发该错误。

    java.lang.InstantiationError 

    实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常. 

    java.lang.InternalError 

    内部错误。用于指示Java虚拟机发生了内部错误。

    java.lang.LinkageError 

    链接错误。该错误及其所有子类指示某个类依赖于另外一些类,在该类编译之后,被依赖的类改变了其类定义而没有重新编译所有的类,进而引发错误的情况。

    java.lang.NoClassDefFoundError 

    未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类,而找不到该类的定义时抛出该错误。

    java.lang.NoSuchFieldError 

    域不存在错误。当应用试图访问或者修改某类的某个域,而该类的定义中没有该域的定义时抛出该错误。

    java.lang.NoSuchMethodError 

    方法不存在错误。当应用试图调用某类的某个方法,而该类的定义中没有该方法的定义时抛出该错误。

    java.lang.OutOfMemoryError 

    内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。

    java.lang.StackOverflowError 

    堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。

    java.lang.ThreadDeath 

    线程结束。当调用Thread类的stop方法时抛出该错误,用于指示线程结束。

    java.lang.UnknownError 

    未知错误。用于指示Java虚拟机发生了未知严重错误的情况。

    java.lang.UnsatisfiedLinkError 

    未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。

    java.lang.UnsupportedClassVersionError 

    不支持的类版本错误。当Java虚拟机试图从读取某个类文件,但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候,抛出该错误。

    java.lang.VerifyError 

    验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。

    java.lang.VirtualMachineError 

    虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。

    java.lang.ArithmeticException 

    算术条件异常。譬如:整数除零等。

    java.lang.ArrayIndexOutOfBoundsException 

    数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

    java.lang.ArrayStoreException 

    数组存储异常。当向数组中存放非数组声明类型对象时抛出。

    java.lang.ClassCastException 

    类造型异常。假设有类A和B(A不是B的父类或子类),O是A的实例,那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。

    java.lang.ClassNotFoundException 

    找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

    java.lang.CloneNotSupportedException 

    不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。

    java.lang.EnumConstantNotPresentException 

    枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象,但该枚举对象并不包含常量时,抛出该异常。

    java.lang.Exception 

    根异常。用以描述应用程序希望捕获的情况。

    java.lang.IllegalAccessException 

    违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法,而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。

    java.lang.IllegalMonitorStateException 

    违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象(O)的监控器或者通知其他线程等待该对象(O)的监控器时,抛出该异常。

    java.lang.IllegalStateException 

    违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态,而调用了该方法时,抛出该异常。

    java.lang.IllegalThreadStateException 

    违法的线程状态异常。当县城尚未处于某个方法的合法调用状态,而调用了该方法时,抛出异常。

    java.lang.IndexOutOfBoundsException 

    索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时,抛出该异常。

    java.lang.InstantiationException 

    实例化异常。当试图通过newInstance()方法创建某个类的实例,而该类是一个抽象类或接口时,抛出该异常。

    java.lang.InterruptedException 

    被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态,而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。

    java.lang.NegativeArraySizeException 

    数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。

    java.lang.NoSuchFieldException 

    属性不存在异常。当访问某个类的不存在的属性时抛出该异常。

    java.lang.NoSuchMethodException 

    方法不存在异常。当访问某个类的不存在的方法时抛出该异常。

    java.lang.NullPointerException 

    空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。

    java.lang.NumberFormatException 

    数字格式异常。当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常。

    java.lang.RuntimeException 

    运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。

    java.lang.SecurityException 

    安全异常。由安全管理器抛出,用于指示违反安全情况的异常。

    java.lang.StringIndexOutOfBoundsException 

    字符串索引越界异常。当使用索引值访问某个字符串中的字符,而该索引值小于0或大于等于序列大小时,抛出该异常。

    java.lang.TypeNotPresentException 

    类型不存在异常

     

    展开全文
  • Java异常处理最佳实践

    千次阅读 2019-06-30 18:38:55
    这也是绝大多数开发团队都会制定一些规则来规范进行异常处理的原因。而团队之间的这些规范往往是截然不同的。 本文给出几个被很多团队使用的异常处理最佳实践。 在 finally 块中清理资源或者使用 try-with-resource...
  • Java异常处理流程

    千次阅读 多人点赞 2019-09-29 10:56:56
    Java应用中,异常处理机制分为抛出异常和捕获异常。 文章目录1. 抛出异常2. 捕获异常3. 异常的抛出与捕获3.1 直接抛出异常3.2 封装异常再抛出3.3 捕获异常3.4 自定义异常3.5 try-catch-finally3.6 try-with-...
  • Java接口和实现的异常处理

    千次阅读 2015-01-06 09:30:03
    1、接口类 package cn.toltech.jdkt; /** * Created by sz0816 on 15-1-6. */ public interface IStudent { void test() throws Exception; void test1(); } 2、实现类 package cn.toltech.jdkt; /** * ...
  • Java异常处理

    千次阅读 热门讨论 2014-03-28 17:39:33
    异常处理一直都是程序设计中一个重要的方面,不管是哪种语言都有这个东西。个人认为异常其实指的是一种错误,但不是说每一种错误都是异常。而java异常中的错误指的是程序在运行中发生的一种现象,比如说某数除以0,...
  • Java自定义异常(优雅的处理异常)

    万次阅读 多人点赞 2018-03-16 15:38:59
    在复杂业务环境下,java自带的异常可能满足不了我们业务的需求, 这个时候我们可以自定义异常来进行对业务异常处理; 首先,我们先对异常进行基本的解释: Throwable是所有Java程序中错误处理的父类 ,有两种子类:...
  • Java编程:关于Java异常处理机制

    千次阅读 2016-07-08 13:55:43
    关于接口调用的404异常处理方式:a) 记录异常信息日志; b) 将异常信息以邮件的形式发出; 关于接口调用的超时异常处理方式:a) 记录异常信息日志; b) 将异常信息以邮件的形式发出; c) 超时后隔五分钟调用一次...
  • java异常的捕获及处理

    万次阅读 多人点赞 2019-03-16 15:28:13
    一、Java异常简介 ...Java提供了更加优秀的解决办法:异常处理机制。 异常处理机制能让程序在异常发生时,按照代码的预先设定的异常处理逻辑,针对性地处理异常,让程序尽最大可能恢复正常并继续...
  • Java异常面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:15:59
    受检异常与非受检异常受检异常非受检异常Java异常关键字Java异常处理声明异常抛出异常捕获异常如何选择异常类型常见异常处理方式直接抛出异常封装异常再抛出捕获异常自定义异常try-catch-finallytry-with-r...
  • Java 异常处理

    千次阅读 2018-04-05 09:03:00
    Java 异常处理异常是程序中的一些错误,但并不是所有的错误都是异常,并且错误有时候是可以避免的。比如说,你的代码少了一个分号,那么运行出来结果是提示是错误 java.lang.Error;如果你用System.out.println(11/0...
  • java统一异常处理

    万次阅读 2017-05-11 15:53:53
    Error是系统级别的错误,程序代码无法处理的,比如OutOfMemoryError、ThreadDeath等。这些错误发生时,JVM一般会选择线程终止退出,它表示程序在运行期间出现了十分严重、不可恢复的错误,应用程序只能中止运行。...
  • java 详解异常处理原理

    千次阅读 2014-07-17 23:01:28
    一、Java异常处理机制的优点 在一些传统的编程语言,如C语言中,并没有专门处理异常的机制,程序员通常用方法的特定返回值来表示异常情况,并且程序的正常流程和异常流程都采用同样的流程控制语句。 Java语言...
  • Java线程池异常处理机制

    千次阅读 2018-05-15 20:32:42
    不论是直接还是间接,各种服务器...关于线程池的各种文章,多数是关注任务的创建和执行方面,对于异常处理和任务取消(包括线程池关闭)关注的偏少。接下来,本文将从 Java 原生线程、两种主要线程池 ThreadPoolEx...
  • Dubbo 接口异常处理逻辑

    千次阅读 2019-10-30 17:33:29
    API 接口中抛出的异常类型,有一系列的规则,代码在 ExceptionFilter 的 onResponse 中。 1. 如果是受检异常(非Runtime)就直接抛出 这是因为如果是受检异常接口定义的 throws 中需要涵盖,调用端需要捕获该异常...
  • 主要介绍了java 抛出异常处理的方法的相关资料,throws关键字通常被应用在声明方法时,用来指定可能抛出的异常,这里就讲下如何使用,需要的朋友可以参考下
  • Java 8 Lambda 异常处理

    千次阅读 2018-09-09 13:03:32
    Java 8 Lambda 异常处理 java8 lambda表达式利用函数式编程提供精简的方式表达行为。然而,JDK函数式接口没有很好地处理异常,使得处理异常代码非常臃肿和麻烦。本文探讨在lambda表达式中处理异常的一些方式。 ...
  • JAVA异常和自定义异常处理

    千次阅读 2019-01-30 23:04:03
    作为一个码农想必对异常这一块滴已经是相当熟悉了就是我们常说的try/catch/finally吗,然后抛出捕获的异常信息,那么当我们在开发中有些异常需要我们给出特定的提示统一对异常进行处理展示可能就会用到自定义异常。...
  • JAVA异常处理原理

    千次阅读 2018-05-25 22:54:05
    一、Java异常处理机制的优点在一些传统的编程语言,如C语言中,并没有专门处理异常的机制,程序员通常用方法的特定返回值来表示异常情况,并且程序的正常流程和异常流程都采用同样的流程控制语句。Java语言按照面向...
  • JAVA异常基本处理

    千次阅读 2018-09-20 23:29:05
    毫无章法,为应用代码的维护和问题的处理挖了很多坑,让后来维护跟进应用的人想直接问候你妈的心都有,下面根据我的一些经验为大家聊聊作为Java程序猿必须要懂的一些异常处理的指引。 一.关于java异常的基础知识 ...
  • JAVA语言如何进行异常处理

    千次阅读 2016-08-14 19:58:33
    Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的 接口。在Java中,每个异常都是一个对象,它是Throwable类或其它子类的实例。当一 个方法出现异常后便抛出一个异常对象,该对象中...
  • Java】J2EE异常处理设计整理

    万次阅读 2020-02-17 19:46:15
    我们在处理应用中的异常时,通常可以将应用中所遇到的异常分为两大类,一种是业务异常,一种是非业务异常。 业务异常是指在进行正常的业务处理时,由于某些业务的特殊需求而导致处理不能继续执行所抛出的异常,这种...
  • java 异常分类和处理机制

    万次阅读 多人点赞 2018-06-01 15:08:26
    Java语言中的异常处理机制就解决的上述问题,把错误与异常的管理带到了面向对象的世界 Java语言定义了很多异常类,将运行错误和异常的信息和处理方法封装在了异常类中,帮助程序员检查和控制异常。即J.....
  • Java异常以及处理原则

    千次阅读 2015-09-05 18:54:15
    Java异常以及处理原则 原则 Java的基本理念是“结构不佳的代码不能运行”。 发现错误的理想时机是在编译阶段,也就是在你试图运行程序之前。然而,编译期并不能找出所有的错误,余下的问题必须在运行期间解决。...
  • 谈谈Java异常处理

    千次阅读 2006-05-02 09:46:00
    1.很多新手碰到异常处理的时候都偷懒不想看,觉得没有必要,其实只是新手的代码就那么几行还体会不到异常处理的好处,自然不想看了嘛,可是学习不是马虎的事嘛!!那么我们为什么需要异常处理呢??早期的编程语言...
  • java异常处理机制详解

    千次阅读 2012-07-29 20:55:22
    是否肯定自己已经全面掌握了Java异常处理机制?在下面这段代码中,你能够迅速找出异常处理的六个问题吗? 1 OutputStreamWriter out = ... 2 java.sql.Connection conn = ... 3 try { // ⑸ 4 Statement ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 433,627
精华内容 173,450
关键字:

java接口的异常处理

java 订阅