Java中异常处理示例

avatar 2017年04月30日23:40:12 1 2106 views
博主分享免费Java教学视频，B站账号：Java刘哥

Exception 的三个方法

  1. package com.liuyanzhao;
  2. class ZeroException {
  3.     int div(int a,int b) throws Exception{
  4.         return a/b;
  5.     }
  6. }
  8. public class Demo {
  9.     public static void main(String[] args) {
  10.         ZeroException z= new ZeroException();
  11.         try {
  12.             int x = z.div(4, 0);
  13.             System.out.println(x);
  14.         } catch( Exception e) {
  15.             System.out.println(e.getMessage());/// by zero
  16.             System.out.println(e.toString());//java.lang.ArithmeticException: / by zero
  17.             e.printStackTrace();/*java.lang.ArithmeticException: / by zero
  18.     at com.liuyanzhao.FushException.div(ExceptionDemo.java:7)
  19.     at com.liuyanzhao.ExceptionDemo.main(ExceptionDemo.java:15)*/
  20.             System.out.println("除0啦");//除0啦
  21.         }
  23.     }
  24. }

一个简单的try-catch语句块

  1. package com.liuyanzhao;
  2. class ZeroException{
  3.     int div(int a,int b) throws Exception{
  4.         return a/b;
  5.     }
  6. }
  8. public class Demo {
  9.     public static void main(String[] args) {
  10.         ZeroExceptionz= new ZeroException();
  11.         try {
  12.             int x = z.div(4, 0);
  13.             System.out.println(x);
  14.         } catch( Exception e) {
  15.             System.out.println(e.toString());//java.lang.ArithmeticException: / by zero
  16.         }
  18.     }
  19. }

ducking只是在踢皮球，方法和main都抛出

  1. package com.liuyanzhao;
  2. /*
  3.  * 1、 div()已经抛掉了异常
  4.  *       连main()抛掉了异常
  5.  *       最后只剩下Java虚拟机，你知道这家伙对异常是没有什么责任感的
  6.  *       Java虚拟机只好死给你看
  7.  * 2、 两者都躲避异常，因此没有人来处理
  8.  *       但有抛掉了，所以可以通过编译
  9.  * 3、 本例的div方法的内的异常是输入RuntimeException
  10.  *       所以它后面的声明异常(throws Exception)是可有可无的，可以省略
  11.  *       但是main方法里要么try/catch处理，要么throws抛掉
  12.  */
  14. class ZeroException{
  15.     int div(int a,int b) throws Exception {
  16.         return a/b ;
  17.     }
  18. }
  20. public class Demo {
  21.     public static void main(String[] args) throws Exception {
  22.         ZeroException z= new ZeroException();
  23.         int x = z.div(4, );
  24.         System.out.println(x);
  25.         /* 正常编译，不美观的异常
  26.          * Exception in thread "main" java.lang.ArithmeticException: / by zero   
  27.            at com.liuyanzhao.FushException.div(Demo.java:4)
  28.            at com.liuyanzhao.Demo.main(Demo.java:11)
  29.          */
  30.     }
  31. }

自定义异常信息和多个catch

  1. package com.liuyanzhao;
  2. /*
  3.  * 1、throws是在方法声明后面
  4.  *    throw是在方法里面
  5.  * 2、自定义异常信息，需要继承父类Exception
  6.  * 3、有多个catch，需要从小到大
  7.  * 4、异常也是多态的
  8.  *   别忘了异常也是对象
  9.  *   除了可以被抛出外，也没什么特别的
  10.  * 5、可以用super来处理所有异常
  11.  *   并不代表就应该这样做  
  12.  */
  14. class FushException extends Exception{
  15.     private String message;
  16.     public String getMessage() {
  17.         return message;
  18.     }
  19.     public FushException(String message) {
  20.         this.message = message;
  21.         //super(message);
  22.     }
  23.       int div(int a,int b) throws FushException {
  24.         if(b<0)
  25.             throw new FushException("除数不能为负数");
  26.         return a/b ;
  27.     }
  28. }
  30. public class Demo {
  31.     public static void main(String[] args) {
  32.         try {
  33.             FushException f = new FushException("");
  34.             int x = f.div(4,-1);
  35.             System.out.println(x);
  36.         } catch (FushException e) {
  37.             System.out.println(e.getMessage());
  38.         } catch(ArithmeticException e) {
  39.             System.out.println(e.getMessage());
  40.         } catch(Exception e) {
  41.             System.out.println(e.getMessage());
  42.         }
  43.     }
  44. }

异常处理规则

①catch和finally不能没有try

  1. public static void main(String[] args) {
  2.     //try {
  3.         FushException f = new FushException();
  4.         int x = f.div(4, -1);
  5.         System.out.println(x);
  6.     //}
  7.     catch (FushException e) {
  8.         System.out.println(e.getMessage());
  9.     }
  10. }
无法通过编译

②try与catch之间不能有程序

  1. public static void main(String[] args) {
  2.         try {
  3.             FushException f = new FushException();
  4.             int x = f.div(4, -1);
  5.             System.out.println(x);
  6.         }
  7.         int a = 1;//中间不能插入代码
  8.         catch (FushException e) {
  9.             System.out.println(e.getMessage());
  10.         }
  11.     }
无法通过编译

③try一定要有catch或finally

  1. public static void main(String[] args) {
  2.         try{
  3.             FushException f = new FushException();
  4.             int x = f.div(4,-1);
  5.             System.out.println(x);
  6.         }
  7. //      catch(FushException e) {
  8. //          System.out.println(e.getMessage());
  9. //      }
  10.         finally {
  11.             //清理
  12.         }
  13. }
这个是合法的，可以通过编译。catch和finally至少需要有一个，但还是要注意 第④项

④自带有finally的try必须要声明异常

  1. public static void main(String[] args) throws FushException{
  2.         try{
  3.             FushException f = new FushException();
  4.             int x = f.div(4,-1);
  5.             System.out.println(x);
  6.         }
  7.         finally {
  8.             //清理
  9.         }
  10.     }
main必须要throws 异常，可以编译     本文地址：http://liuyanzhao.com/3919.html 转载请注明
历史上的今天
四月
30日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0