精华内容
下载资源
问答
  • Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。所有的RuntimeException类及其子类的实例被称为Runtime异常;不是RuntimeException类及其子类的异常实例则被称为Checked异常。 对于Checked异常...

    Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。所有的RuntimeException类及其子类的实例被称为Runtime异常;不是RuntimeException类及其子类的异常实例则被称为Checked异常。
    对于Checked异常的处理方式有如下两种:

    1. 当前方法明确知道如何处理该异常,程序应该使用try…catch块来捕获该异常,然后在对应的catch块中修复该异常
    2. 当前方法不知道如何处理这种异常,应该在定义该方法时声明抛出该异常。

    使用throws声明抛出异常

    使用throws声明抛出异常的思路是:当前方法不知道如何处理这种类型的异常,该异常应该由上一级调用者处理;如果mian方法也不知道如何处理这种类型的异常,也可以使用throws声明抛出异常,该异常将交给JVM处理。JVM对异常的处理方法是:打印异常的跟踪栈信息,并中止程序运行。

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class ThrowsTest{
    	public static void main(String[] args) throws FileNotFoundException{
    		test();
    	}		
    	
    	public static void test() throws FileNotFoundException{
    		FileInputStream fis = new FileInputStream("a.txt");
    	}
    }
    
    

    如果某段代码中调用了一个带throws声明的方法,该方法声明抛出了Checked异常,则表明该方法希望它的调用者来处理该异常。

    使用throws声明抛出异常时有一个限制,就是方法重写时遵循:子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同,子类方法声明抛出的异常不允许比父类方法声明抛出的异常多。

    展开全文
  • Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。所有的RuntimeException类及其子类的实例被称为Runtime异常;不是RuntimeException类及其子类的异常实例则被称为Checked异常。 Java程序必须显式...

    Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。所有的RuntimeException类及其子类的实例被称为Runtime异常;不是RuntimeException类及其子类的异常实例则被称为Checked异常。

    Java程序必须显式处理Checked异常,如果程序没有处理Checked异常,该程序在编译时就会发生错误,无法通过编译。

    Runtime异常则更加灵活,Runtime异常无须显式声明抛出,如果程序需要捕获Runtime异常,也可以使用try...catch块来实现。

    使用throws声明抛出异常时有一个限制,就是方法重写时“两小”中的一个规则,子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同,子类方法声明抛出的异常不允许比父类方法声明抛出的异常多。

    在大部分时候推荐使用Runtime异常,而不使用Checked异常。尤其当程序需要自行抛出异常时,使用Runtime异常将更加简洁。

    当使用Runtime异常时,程序无须在方法中声明抛出Checked异常,一旦发生了自定义错误,程序只管抛出Runtime异常即可。

    如果程序需要在合适的地方捕获异常并对异常进行处理,则一样可以使用try...catch块来捕获Runtime异常。

    在java的异常类体系中,Error和RuntimeException是非检查型异常,其他的都是检查型异常。

    所有方法都可以在不声明throws的情况下抛出RuntimeException及其子类 
    不可以在不声明的情况下抛出非RuntimeException

    简单的说,非RuntimeException要自己写catch块处理掉。 

    1.RuntimeException 

    首先看一段代码,主要内容就是将字符串类型的数字转化为整型的数字,然后让两个数字相乘,代码如下:

    public class RuntimeException {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String str="123";
            int temp=Integer.parseInt(str);
            System.out.println(temp*temp);
        }
    }

     

    查看parseInt方法的源代码如下:

     public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
        }

     

    我们发现这个方法中抛出了NumberFormatException异常,但是在上面的代码中我们没有找到try...catch来处理,这是为什么呢。按照我们异常处理的知识,如果一个方法通过throws抛出了异常,那么可以在抛出异常的方法中不使用try...catch,但是在调用这个方法的地方必须有try...catch来处理。

    下面来观察NumberFormatException类的继承关系:

    从上图我们可以发现NumberFormatException是RuntimeException的子类,那么这就需要我们清楚Exception和RuntimeException的概念:

    1. Exception:在程序中必须使用try...catch进行处理。
    2. RuntimeException:可以不使用try...catch进行处理,但是如果有异常产生,则异常将由JVM进行处理。

    对于RuntimeException的子类最好也使用异常处理机制。虽然RuntimeException的异常可以不使用try...catch进行处理,但是如果一旦发生异常,则肯定会导致程序中断执行,所以,为了保证程序在出错后依然可以执行,在开发代码时最好使用try...catch的异常处理机制进行处理。

    2.User Defined Exception

    下面给出一个自定义异常的实例:

    class MyException extends Exception{
        public MyException(String msg){
            super(msg);
        }
    }
    
    public class DefaultException {
    
        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            try{
                throw new MyException("自定义异常");
            }catch(Exception e){
                System.out.println(e);//edu.sjtu.ist.comutil.MyException: 自定义异常
                //System.err.println(e);
    //            e.printStackTrace();
    //            StackTraceElement[] sts = e.getStackTrace();
    //            for (StackTraceElement st : sts){
    //                System.err.println(st);
    //            }
    
            //    System.err.println(e.getStackTrace());
            }
    
        }
    
    }

     

    输出结果为:

    MyException: 自定义异常

     

    常见的RuntimeException                                      

    RuntimeException是开发中最容易遇到的,下面列举一下常见的RuntimeException:

    1、NullPointerException:见的最多了,其实很简单,一般都是在null对象上调用方法了。
          String s=null;
          boolean eq=s.equals(""); // NullPointerException
       这里你看的非常明白了,为什么一到程序中就晕呢?
       public int getNumber(String str){
      if(str.equals("A")) return 1;
       else if(str.equals("B")) return 2;
       }
       这个方法就有可能抛出NullPointerException,我建议你主动抛出异常,因为代码一多,你可能又晕了。
       public int getNumber(String str){
      if(str==null) throw new NullPointerException("参数不能为空");
                                       //你是否觉得明白多了
      if(str.equals("A")) return 1;
          else if(str.equals("B")) return 2;
       }

    2、NumberFormatException:继承IllegalArgumentException,字符串转换为数字时出现。比如int i= Integer.parseInt("ab3");

    3、ArrayIndexOutOfBoundsException:数组越界。比如 int[] a=new int[3]; int b=a[3];

    4、StringIndexOutOfBoundsException:字符串越界。比如 String s="hello"; char c=s.chatAt(6);

    5、ClassCastException:类型转换错误。比如 Object obj=new Object(); String s=(String)obj;

    6、UnsupportedOperationException:该操作不被支持。如果我们希望不支持这个方法,可以抛出这个异常。既然不支持还要这个干吗?有可能子类中不想支持父类中有的方法,可以直接抛出这个异常。

    7、ArithmeticException:算术错误,典型的就是0作为除数的时候。

    8、IllegalArgumentException:非法参数,在把字符串转换成数字的时候经常出现的一个异常,我们可以在自己的程序中好好利用这个异常。

    参考资料

    java 中的Exception RuntimeException 区别:http://blog.csdn.net/a_long_/article/details/51146453

    转载于:https://www.cnblogs.com/junzi2099/p/8351492.html

    展开全文
  • Runtime 异常和Checked异常

    千次阅读 2013-05-29 19:25:31
    Java中的异常被分为两类,Checked异常和Runtime异常,即编译时异常和运行时异常。 所有RuntimeException类及其子类的实例被称为Runtime异常. 对于Checked异常的处理方式有两种: 当前方法明确知道如何处理该异常...

    Java中的异常被分为两类,Checked异常和Runtime异常,即编译时异常和运行时异常。

    所有RuntimeException类及其子类的实例被称为Runtime异常.

    对于Checked异常的处理方式有两种:

    1. 当前方法明确知道如何处理该异常,程序应该使用try....catch 块来捕获该异常,然后在对应的catch块中修补该异常.
    2. 当前方法不知道如何处理该异常,应该在定义该方法时声明抛出该异常.

    Runtime异常比较灵活,它无须显示的声明抛出.如果程序需要捕获Runtime异常,也可以使用try....catch 块来捕获Runtime异常.

    下面的代码是一个很好的例子:

    public class TestThrow {
    
    	public static void main(String[] args) {
           
    	   try {
    		   //调用throws声明的方法,必须显示捕获该异常
    		   //否则必须在main方法中再次的声明抛出
    		   throwChecked(3);
    	} catch (Exception e) {
    		System.out.println(e.getMessage());
    	  }
    	    //调用捕获Runtime异常的方法,可以显示的捕获该异常,也可以不理会该异常
    	    throwRuntime(4);
    	}
    	
    	public static void throwChecked(int a) throws Exception{
    		  if(a>0){
    			  //自行抛出Exception异常
    			  //该代码必须处于try块里,或者处于带throws声明的方法中
    			  throw new Exception("a的值大于0,不符合要求");
    		  }
    	}
    	
    	public static void throwRuntime(int a){
    		if(a>0){
    			//自行抛出RuntimeException异常,既可以显示捕获该异常
    			//也可以完全不理会该异常,把该异常交给方法调用者处理
    			throw new RuntimeException("a的值大于零,不符合要求");
    		}
    		
    	}
    
    }
    

    可以看到程序代码中:Runtime异常没有使用throws声明抛出,也没有使用try...catch块来捕获处理。Checked异常就必须声明抛出或者捕获。运行程序代码时,会出现异常.

     

    展开全文
  • 1.Java常见异常类 异常对象常用方法: getMessage():返回异常的详细描述字符串,例如:/ by zero printStackTrace(): ...2.Runtime异常 和 Checked异常区别     Exception...

    1. Java常见异常类

    下面显示了常见异常类之间的继承关系:
    在这里插入图片描述
    异常对象常用方法:

    • getMessage():返回异常的详细描述字符串,例如:/ by zero
    • printStackTrace():将异常的跟踪栈信息输出到标准错误输出
    • printStackTrace(PrintStream s):将异常的跟踪栈信息输出到指定输出流
    • getStackTrace():返回异常的跟踪栈信息

    2. Runtime异常 和 Checked异常区别

        Exception分为Runtime异常和Checked异常,RuntimeException类或其子类 被称为Runtime异常;其它为Checked异常。区别如下:

    2.1 Runtime异常:
        表示无法处理的异常,程序有必要中断;throw Runtime异常,可以不必一定写try…catch 或 throws

    2.2 Checked异常:
        表示可以处理的异常;throw Checked异常,要用throws 或 try … catch,throws即希望调用方来处理,如果一直未得到处理,会将异常交给JVM,JVM会打印跟踪栈信息,并终止程序

    2.3 为什么Runtime异常不用throws 或 有时看到说 Runtime异常不建议 tru…catch???
        之所以不用在函数上声明,是因为不需要让调用者处理,当该异常发生,希望程序停止,因为在运行时,出现了无法继续运算的情况,希望程序停止后由程序员对代码进行修正。但我们通常还是使用try…catch 并记录异常,而不是让程序直接崩掉

        通俗讲: checked 异常 和 RuntimeException 有着不同的使用目的,检查性异常 用来指示 一种调用方能够直接处理的异常情况(例如: 用户输入错误,程序可以直接捕获并处理,提示用户输入错误), 而RuntimeException 是用来指 调用方 本身无法 处理或回复 的程序错误(例如,你封装个库给别人用,当别人调用你库中某个方法是,需要传入某些参数,如果用户传入的参数不合法,你自己没办法处理,那么此刻你抛出的就应该是运行时异常)

    3. @Transactional注解事务回滚分析

        @Transactional 默认只回滚Runtime异常,为什么只能回滚Runtime异常,个人任务:Runtime异常是无法预知的异常,无法预知是什么错该怎么处理,所以干脆就回滚所有;但Check异常,属于可被检查的异常,我这理解为可预知异常,都能预知,所以我们可以处理当遇到这种错误时该做什么错做,比如只撤销几步操作。
    所以在使用@Transactional 最好控制下回滚的范围@Transactional(rollbackFor = Throwable.class

    注意点:

    1. 只有代理类调用才会走进事务,即Bean调用,所以被@Transactional标注的方法一定是public,protect也不行,无法正常代理
    2. 内部调用无法正常代理,可以通过Bean调用
    @Service
    public class Test {
    
        @Autowired
        private Test test;
        
        public void b() {
            //这样事务没生效
            this.a();
            //这样事务生效了
            test.a();
        }
        
        @Transactional(rollbackFor = Throwable.class)
        public void a() {
        }
    }
    

    4. 打印不完整的堆栈信息

        最近出现 java.lang.ArithmeticException: null 异常,但是没有给出详细的堆栈信息,但是发现最初有java.lang.ArithmeticException: /by zero 异常,发现是由于1/0,除数为0情况造成的,但奇怪的是后来即使再有1/0情况也不报java.lang.ArithmeticException: /by zero 异常,反而只出现了 java.lang.ArithmeticException: null这一行异常信息,奇怪的是没有完整堆栈信息,只有这个简要的错误信息,就猜测还是1/0造成的此错误,修改1/0错误后,确实就没再出现java.lang.ArithmeticException: null异常。
        经查资料得知:JVM在多次遇到同一异常信息时,前几次会输出堆栈信息,后面就会主动优化掉,只反馈异常摘要信息,即JIT重新编译后会抛出没有堆栈的异常,而在使用-server模式时,该优化选项是开启的,因此在频繁抛出某个异常一段时间后,该优化开始起作用,即只抛出没有堆栈的异常信息,这种异常抛出速度非常快,因为不需要在堆里分配内存,也不需要构造完整的异常栈信息.所以遇到这种情况,往前翻日志就可以看到异常的具体信息了。可以在jvm启动参数增加 -XX:-OmitStackTraceInFastThrow,字面意思:忽略异常栈信息从而快速抛出,就可以始终抛出含异常的堆栈信息了,但是我们运行的项目不可能去重启去修改此参数,修改默认的jvm参数还是需要一定经验的,所以就去翻前的日志就可以了(推荐文章:https://www.jianshu.com/p/cc1bd35466cb)。
        还有一点疑惑:就算是优化也应该是只打印java.lang.ArithmeticException: /by zero ,而不是java.lang.ArithmeticException: null???e.getMessage()message怎么也会变化那,难道是连错误信息也会优化???欢迎广大朋友留言

    一般不会出现这种情况,如果想在本地复现,可以使用如下代码测试:

    public void test() {
            for (int i = 0; i < 200000; i++) {
                try {
                    System.out.println(i);
                    int ii = 1 / 0;
                } catch (Exception e) {
                    // 由 2 变为了 0
                    System.out.println(e.getStackTrace().length);
                    // 由 / by zero 变为了 null
                    System.out.println(e.getMessage());
                }
            }
        }
    

    会发现

    1. e.getStackTrace().length输出由2会变为0
    2. e.getMessage() 输出 由/ by zero 变为了null

    但是如果设置 -XX:-OmitStackTraceInFastThrow
    在这里插入图片描述
    会发现

    1. e.getStackTrace().length永远输出2
    2. e.getMessage() 永远输出 / by zero
    展开全文
  • Java 异常分为两大类:Checked 异常Runtime 异常(运行时异常)。 使用 throws 声明抛出异常 上面程序声明不处理 IOException 异常,将该异常交给 JVM 处理,所以程序一旦遇到该异常,JVM 就会打印该异常的...
  • Checked异常和Runtime异常体系  2012-07-03 22:23:02| 分类: java学习日志|举报|字号 订阅  Java的异常被分为两大类:Checked异常和Runtime异常(运行时异常)。所有RuntimeException类...
  • 文章目录开发中如何避免runtime 异常空指针异常数组下标越界数学运算异常数字格式异常异常处理思路: 开发中如何避免runtime 异常 如何在开发中避免bug,示例是java代码 空指针异常 java.lang....
  • Check异常和Runtime异常体系Java的异常被分为两大类,Check异常(检查期异常)和Runtime异常(编译时异常),所有的RuntimeException以及子类都被称为运行时异常,除了运行时异常的都是检查期异常。其中运行时异常...
  • Check异常和Runtime异常体系Java的异常被分为两大类,Check异常(检查期异常)和Runtime异常(编译时异常),所有的RuntimeException以及子类都被称为运行时异常,除了运行时异常的都是检查期异常。其中运行时异常...
  • 3-Checked异常和Runtime异常 1.概述 (1)所有的RuntimeException类及其子类的实例都被称为Runtime异常;不是RuntimeException类及其子类的异常实例则被称为Checked异常; (2)Java程序必须显式处理Checked异常...
  • Java中常见的RunTime异常及异常详解

    万次阅读 2016-08-11 09:52:49
    常见的RunTime异常几种如下: NullPointerException - 空指针引用异常 ClassCastException - 类型强制转换异常。 IllegalArgumentException - 传递非法参数异常。 ArithmeticException - 算术运算异常 ...
  • checked异常和runtime异常 只有java语言提供了checked异常。java认为checked异常都是可以被处理和修复的,所以java程序必须显示处理checked异常,否则不能通过编译。 runtime异常可以不捕获,当人也可以捕获。 ...
  • JAVA的异常(三):runtime异常 Exception中有一个特殊的子类异常RuntimeException 运行时异常  1如果在函数内抛出该异常,函数上可以不用声明,编译一样通过  2 如果在函数上声明了该异常,调用者...
  • java.lang.ArithmeticException算术条件异常。譬如:整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组...
  • Java 的异常被分为两大类:Checked 异常Runtime 异常(运行时异常)。所有的 RuntimeException 类及其子类的实例被称为 Runtime 异常:不是 RuntimeException 类及其子类的异常实例则被称为 Checked 异常
  • 最看在看一些安卓图形绘制的代码,看到一个函数的注释里提到了Runtime这个概念:一些代码中的注释Runtime是运行时的意思,Runtime Error就是运行时错误,就是在运行期间出现的错误。An error that occurs during the...
  • 参考:https://segmentfault.com/q/1010000012438163
  • Java中所有异常的父类是Throwable类,在Throwable类下有两大子类:一个是Error类,指系统错误异常,例如:VirtualMachineError 虚拟机错误,ThreadDeath 线程死锁。一般如果是Error类的异常的话,就是程序的硬伤,就...
  • 常见的几种RuntimeException异常如下NullPointerException//空指针引用异常ClassCastException//类型强制转换异常IllegalArgumentException//传递非法参数异常ArithmeticException//算术运算异常ArrayStoreException...
  • 运行时异常或未检查的异常是在执行时发生的异常。其中包括编程错误,例如逻辑错误或 API 使用不当。运行时异常在编译时被忽略。IndexOutOfBoundsException,ArithmeticException,ArrayStoreException和...
  • 捕获runtime异常

    2013-05-08 14:37:31
    记住以下几个函数,在程序里设置它们,可以保证程序不弹出对话框,这在排查错误时很有用: _set_abort_behavior( 0, _WRITE_ABORT_MSG);  _set_abort_behavior(0, _CALL_REPORTFAULT);  _set_purecall_handler...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,980
精华内容 1,992
关键字:

runtime异常