devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java异常的捕获与处理（下）_java中calculate.div

作者：IT小白 | 2024-04-06 15:40:41

赞

踩

java中calculate.div

 

 

 

java异常的捕获与处理（上）认识了异常以及异常的处理流程。

一、throws关键字

throws关键字主要是在方法定义上使用的，表示的是此方法不在进行异常的处理，而是抛给被调用处处理。

范例：
 

  1. class Calculate{
  2.     public int div(int x,int y)throws Exception{
  3.         return x/y;
  4.     }
  5. }

现在div()方法抛出了一个异常出来，表示所有的异常交给被调用处进行处理。

范例2：

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/5/29 20:48
  6.  */
  7.  
  8. class Calculate{
  9.     public int div(int x,int y)throws Exception{
  10.         return x/y;
  11.     }
  12. }
  13. public class TestDemo {
  14.     public static void main(String[]args) {
  15.         try {
  16.             System.out.println(new Calculate().div(10, 0));
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

运行结果：

  1. java.lang.ArithmeticException: / by zero
  2. 	at com.wfg.demo.Calculate.div(TestDemo.java:10)
  3. 	at com.wfg.demo.TestDemo.main(TestDemo.java:16)
  4.

注意：在调用throws声明方法的时候，一定要使用异常处理操作进行异常的处理，这属于强制性的处理。

而主方法也属于方法，那么在主方法上也可以继续使用throws进行异常的抛出：
 

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/5/29 20:48
  6.  */
  7.  
  8. class Calculate{
  9. public int div(int x,int y)throws Exception{
  10.         return x/y;
  11.         }
  12.         }
  13. public class TestDemo {
  14.     public static void main(String[]args) throws Exception {
  15.         System.out.println(new Calculate().div(10, 0));
  16.     }
  17. }

运行结果：
 

  1. Exception in thread "main" java.lang.ArithmeticException: / by zero
  2. 	at com.wfg.demo.Calculate.div(TestDemo.java:10)
  3. 	at com.wfg.demo.TestDemo.main(TestDemo.java:15)

在这里，主方法将异常继续向上抛，交给JVM进行异常处理，也就是采用了默认的方式，输出异常信息，而后结束程序执行。

注意：在实际开发中，主方法不要叫throws，因为程序如果有异常，我们也希望可以正常结束。

二、throw关键字

之前所有的异常对象都是由JVM自动进行实例化操作的，用户其实也可以手动的抛出一个异常类实例化对象，throw关键字就是这个作用。

范例：

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/5/29 20:48
  6.  */
  7.  
  8. public class TestDemo {
  9.     public static void main(String[]args){
  10.         try {
  11.             throw new Exception("自定义的异常");
  12.         } catch (Exception e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

运行结果：

  1. java.lang.Exception: 自定义的异常
  2. 	at com.wfg.demo.TestDemo.main(TestDemo.java:11)

throw和throws的区别？

（1）throw：在方法体内使用，表示人为的抛出一个异常类对象（这个对象可以是自己实例化的，也可以是已存在的）；

（2）throws:在方法的声明上使用，表示此方法中不进行异常的处理，而交给被调用处处理。

三、异常处理标准格式

把上面的例子做一些改变：

（1）在进行运算前输出一行提示信息

（2）在运算完毕后，输出一行提示信息

（3）如果中间发生了异常，则交给被调用处处理。

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/5/29 20:48
  6.  */
  7.  
  8. class Calculate{
  9.     public int div(int x,int y)throws Exception{
  10.         System.out.println("====计算开始====");
  11.         int result = 0;
  12.         try {
  13.             result = x/y;//除法运算
  14.         } catch (Exception e) {
  15.             throw e;//向上抛
  16.         } finally {
  17.             System.out.println("====计算结束====");
  18.         }
  19.         return result;
  20.     }
  21. }
  22. public class TestDemo {
  23.     public static void main(String[]args){
  24.         try {
  25.             System.out.println(new Calculate().div(10, 0));
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30. }

运行结果：

  1. ====计算开始====
  2. java.lang.ArithmeticException: / by zero
  3. ====计算结束====
  4. 	at com.wfg.demo.Calculate.div(TestDemo.java:13)
  5. 	at com.wfg.demo.TestDemo.main(TestDemo.java:25)

以上代码可以做一些简化：

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/5/29 20:48
  6.  */
  7.  
  8. class Calculate{
  9.     public int div(int x,int y)throws Exception{
  10.         System.out.println("====计算开始====");
  11.         int result = 0;
  12.         try {
  13.             result = x/y;//除法运算
  14.         } finally {
  15.             System.out.println("====计算结束====");
  16.         }
  17.         return result;
  18.     }
  19. }
  20. public class TestDemo1 {
  21.     public static void main(String[]args){
  22.         try {
  23.             System.out.println(new Calculate().div(10, 0));
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28. }

运行结果：
 

  1. java.lang.ArithmeticException: / by zero
  2. ====计算开始====
  3. ====计算结束====
  4. 	at com.wfg.demo.Calculate.div(TestDemo1.java:13)
  5. 	at com.wfg.demo.TestDemo1.main(TestDemo1.java:23)

直接使用try...finally，不带catch，那么就连处理的机会都没有了，所以不建议使用try...finally。标准的格式是try...catch、finally、throws、throw一起使用

四、RuntimeException类

首先观察下面例子：

  1. package com.wfg.demo;
  2.  
  3. /**
  4.  * @Author WFG
  5.  * @Date 2019/6/1 18:40
  6.  */
  7. public class TestDemo2 {
  8.     public static void main(String[]args){
  9.         String str = "123";
  10.         int num = Integer.parseInt(str);
  11.         System.out.println(num*num);
  12.     }
  13. }

运行结果：

15129

这个程序就是将一个字符串变为了基本数据类型（具体用法参见java三大特殊类之包装类），而后执行乘法操作，查看parseInt()方法的定义：

public static int parseInt(String var0) throws NumberFormatException

可以发现这个方法抛出了一个NumberFormatException的异常，按照之前的理解，如果存在了throws，则必须用try...catch进行处理，可是现在没有强制要求处理，这是为什么呢？

查看NumberFormatException的继承结构：

可以发现，NumberFormatException属于RuntimeException的子类，而在java中明确规定：对于RuntimeException的异常类型，在编译的时候不会强制性的要求用户处理，用户可以根据需要有选择的进行处理，在开发中，如果没有处理，那么出现异常后将交给JVM默认进行处理。（也就是说，RuntimeException的子异常类，可以由用户根据需要有选择的来进行处理）

小结：RuntimeException和Exception的区别与联系：
（1）RuntimeException是Exception的子类

（2）Exception定义了必须要处理的异常，而RuntimeException定义的异常可以选择性的进行处理

常见的RuntimeException：
NumberFormatException(数字格式异常)、NullPointerException(空指针异常)、ArithmeticException(算术异常)ArrayIndexOutOfBoundsException（数组越界）

五、断言（assert关键字）

java中断言指的是程序执行到某行后，其结果一定是预期的结果，在JDK1.4之后增加了一个assert的关键字。为了区别与之前代码写的assert，JVM的断言是默认关闭的。

两种语法格式：
（一）

assert condition;

这里的condition是一个必须为真（true）的表达式。如果表达式的结果为true，那么断言为真，并且无任何动作，如果表达式为false，则断言失败，则会抛出一个AssertionError对象。这个AssertionError继承与Error对象。

（二）

assert condition:expr;

这里的condition是和上面一样的，冒号后跟的是一个表达式，通常用于断言失败后的提示信息，其实就是一个传到AssertionError构造函数的值，如果断言失败，该值被转化为它对应的字符串，并显示出来。

范例（使用断言）：

  1. /**
  2.  * @Author WFG
  3.  * @Date 2019/6/1 17:44
  4.  */
  5. public class Test {
  6.     public static void main(String[]args){
  7.         int x = 10;
  8.         x +=21;
  9.         assert x ==10:"x的值不是10";
  10.         System.out.println(x);
  11.     }
  12. }

默认情况下，Java去中的断言，不会在正常执行的代码中出现，如果想要启用断言，则应该增加-ea选项：
 

java -ea Test

操作如下：

  1. F:\JAVA\WFGproject\generic>cd out\production\generic\
  2.  
  3. F:\JAVA\WFGproject\generic\out\production\generic>java -ea Test

运行结果：

  1. Exception in thread "main" java.lang.AssertionError: x的值不是10
  2.         at Test.main(Test.java:9)

六、自定义异常

在java中本身已经提供了大量的异常，但是在开发中，这些异常类型还不能满足于开发的需要，所以在一些系统架构之中，往往会提供一些新的异常的类型，来表示一些特殊的错误，而这种操作就称为自定义异常类，而想要实现这种自定义的异常类，那么可以让一个类继承Exception或RuntimeException。

范例：

  1. /**
  2.  * @Author WFG
  3.  * @Date 2019/5/29 17:44
  4.  */
  5. class MyException extends Exception {//自定义异常类
  6.     public MyException(String str) {
  7.         super(str);
  8.     }
  9. }
  10. public class Test {
  11.     public static void main(String[]args) throws Exception{
  12.         throw new MyException("自定义的异常类");
  13.     }
  14. }

运行结果：
 

  1. Exception in thread "main" MyException: 自定义的异常类
  2. 	at Test.main(Test.java:12)

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/372848
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号