感觉JVM的默认异常处理不够好,既然不好那我们就自己来处理异常呗!那么如何自己处理异常呢?

* 如果程序出现了问题,我们没有做任何处理,最终JVM会做出默认的处理。 * 把异常的名称原因出现的位置等信息输出在控制台。同时会结束程序。 * * 但是呢,其余没有问题的程序就不能继续执行了。 * 所以感觉JVM的默认异常处理不够好,既然不好那我们就自己来处理异常呗!那么如何自己处理异常呢?

* 异常的处理方案 *    A:try...catch...finally *      自己编写处理的代码,后面没有问题的程序可以继续执行。 *    B:throws 抛出 *      把自己处理不了的异常,在方法上声明,告诉调用者,这里有问题。

  示例代码如下:

 1 package cn.itcast_02;
 2 
 3 /* 
 4  * 如果程序出现了问题,我们没有做任何处理,最终JVM会做出默认的处理。
 5  * 把异常的名称、原因及出现的位置等信息输出在控制台。同时会结束程序。
 6  *            
 7  * 但是呢,其余没有问题的程序就不能继续执行了。
 8  * 所以感觉JVM的默认异常处理不够好,既然不好那我们就自己来处理异常呗!那么如何自己处理异常呢?
 9  * 
10  * 异常的处理方案
11  *         A:try...catch...finally
12  *             自己编写处理的代码,后面没有问题的程序可以继续执行。
13  *         B:throws 抛出
14  *             把自己处理不了的异常,在方法上声明,告诉调用者,这里有问题。
15  * 
16  * try...catch...finally的处理格式:
17  *         try {
18  *             可能出现问题的代码;
19  *         } catch (异常类名 变量名) {
20  *             针对问题的处理;
21  *         } finally {
22  *             释放资源;
23  *         }
24  * 
25  * 变形格式:
26  *         try {
27  *             可能出现问题的代码;
28  *         } catch(异常类名 变量名) {
29  *             针对问题的处理;
30  *         }
31  * 
32  * 注意:
33  *         A:try里面的代码越少越好。
34  *         B:catch里面必须有内容,哪怕是给出一个简单的提示。否则就隐藏了异常。
35  */
36 public class ExceptionDemo {
37     public static void main(String[] args) {
38         // 第一阶段
39         int a = 10;
40         // int b = 2;
41         int b = 0;
42 
43         try {
44             System.out.println(a / b);
45         } catch (ArithmeticException e) { // ArithmeticException 算术异常
46             System.out.println("除数不能为0");
47         }
48 
49         // 第二阶段
50         System.out.println("over");
51     }
52 }

两/多个异常的处理

  示例代码如下:

  1 package cn.itcast_02;
  2 
  3 /*
  4  * A:一个异常的处理
  5  *         try...catch...finally的处理格式:
  6  *             try {
  7  *                 可能出现问题的代码;
  8  *             } catch (异常类名 变量名) {
  9  *                 针对问题的处理;
 10  *             } finally {
 11  *                 释放资源;
 12  *             }
 13  *         变形格式:
 14  *             try {
 15  *                 可能出现问题的代码;
 16  *             } catch(异常类名 变量名) {
 17  *                 针对问题的处理;
 18  *             }
 19  * 
 20  * B:两/多个异常的处理
 21  *         a:每一个异常写一个try...catch
 22  *         b:写一个try,多个catch
 23  *             try {
 24  *                 可能出现问题1的代码;
 25  *                 可能出现问题2的代码;
 26  *                 可能出现问题3的代码;
 27  *                 ...
 28  *             } catch (异常类名1 变量名) {
 29  *                 针对问题1的处理;
 30  *             } catch (异常类名2 变量名) {
 31  *                 针对问题2的处理;
 32  *             } catch (异常类名3 变量名) {
 33  *                 针对问题3的处理;
 34  *             }
 35  *             ...
 36  * 
 37  *             注意事项:
 38  *                 1:能明确具体的异常尽量明确,最好不要用大的异常(父亲)来处理。
 39  *                 2:平级关系的具体的异常谁前谁后无所谓,如果出现了子父关系得异常,父异常必须在后面。
 40  * 
 41  * 注意:
 42  *         一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配,
 43  *         一旦有匹配的,就执行catch里面的处理,然后就结束了try...catch语句,继续执行后面的语句。
 44  */
 45 public class ExceptionDemo2 {
 46     public static void main(String[] args) {
 47         // method1();
 48 
 49         // method2();
 50 
 51         // method3();
 52 
 53         method4();
 54     }
 55     
 56     // 多个异常的处理
 57     public static void method4() {
 58         int a = 10;
 59         int b = 0;
 60         int[] arr = { 1, 2, 3 };
 61 
 62         // 爷爷在最后可以
 63         try {
 64             System.out.println(a / b);
 65             System.out.println(arr[3]);
 66             System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
 67         } catch (ArithmeticException e) {
 68             System.out.println("除数不能为0");
 69         } catch (ArrayIndexOutOfBoundsException e) {
 70             System.out.println("你访问了不该访问的索引");
 71         } catch (Exception e) { // 不知道你出现的异常到底是哪一个具体的异常,反正你是异常,那么就用异常的父类(你的父亲)来接收。即不管我针对哪一个具体的异常都可以处理。
 72             System.out.println("出问题了");
 73         }
 74 
 75         /*
 76         // 爷爷在前面是不可以的
 77         try {
 78             System.out.println(a / b);
 79             System.out.println(arr[3]);
 80             System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
 81         } catch (Exception e) {
 82             System.out.println("出问题了");
 83         } catch (ArithmeticException e) {
 84             System.out.println("除数不能为0");
 85         } catch (ArrayIndexOutOfBoundsException e) {
 86             System.out.println("你访问了不该的访问的索引");
 87         }
 88         */
 89 
 90         System.out.println("over");
 91     }
 92 
 93     // 两个异常的处理:写一个try,多个catch
 94     public static void method3() {
 95         int a = 10;
 96         int b = 0;
 97         int[] arr = { 1, 2, 3 };
 98 
 99         try {
100             System.out.println(arr[3]); 
101             System.out.println(a / b);
102             // System.out.println(arr[3]);
103         } catch (ArithmeticException e) {
104             System.out.println("除数不能为0");
105         } catch (ArrayIndexOutOfBoundsException e) {
106             System.out.println("你访问了不该的访问的索引");
107         }
108 
109         System.out.println("over");
110     }
111 
112     // 两个异常的处理:每一个异常写一个try...catch
113     public static void method2() {
114         int a = 10;
115         int b = 0;
116         try {
117             System.out.println(a / b);
118         } catch (ArithmeticException e) {
119             System.out.println("除数不能为0");
120         }
121 
122         int[] arr = { 1, 2, 3 };
123         try {
124             System.out.println(arr[3]);
125         } catch (ArrayIndexOutOfBoundsException e) {
126             System.out.println("你访问了不该的访问的索引");
127         }
128 
129         System.out.println("over");
130     }
131 
132     // 一个异常的处理
133     public static void method1() {
134         // 第一阶段
135         int a = 10;
136         // int b = 2;
137         int b = 0;
138 
139         try {
140             System.out.println(a / b);
141         } catch (ArithmeticException e) {
142             System.out.println("除数不能为0");
143         }
144 
145         // 第二阶段
146         System.out.println("over");
147     }
148 }

JDK7出现了一个新的异常处理方案及注意事项

  示例代码如下:

 1 package cn.itcast_02;
 2 
 3 /*
 4  * JDK7出现了一个新的异常处理方案及注意事项:
 5  *         try {
 6  *             可能出现问题1的代码;
 7  *             可能出现问题2的代码;
 8  *             ...
 9  *         } catch (异常类名1 | 异常类名2 | ...  变量名 ) {
10  *             针对问题的处理;
11  *         }
12  * 
13  *         注意事项:这个方法虽然简洁,但是也不够好。
14  *             A:对多个异常的处理方式是一致的。(但是实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理方式,是符合我们的开发要求的)
15  *             B:多个异常间必须是平级关系。
16  */
17 public class ExceptionDemo3 {
18     public static void main(String[] args) {
19         method();
20     }
21 
22     public static void method() {
23         int a = 10;
24         int b = 0;
25         int[] arr = { 1, 2, 3 };
26 
27         /*
28         // JDK7以前的异常处理方案
29         try {
30             System.out.println(a / b);
31             System.out.println(arr[3]);
32             System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
33         } catch (ArithmeticException e) {
34             System.out.println("除数不能为0");
35         } catch (ArrayIndexOutOfBoundsException e) {
36             System.out.println("你访问了不该的访问的索引");
37         } catch (Exception e) {
38             System.out.println("出问题了");
39         }
40         */
41 
42         // JDK7出现了一个新的异常处理方案
43         try {
44             System.out.println(a / b);
45             System.out.println(arr[3]);
46         } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
47             System.out.println("出问题了");
48         }
49 
50         System.out.println("over");
51     }
52 
53 }

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏C语言及其他语言

数组越界为什么没有出错

数组越界 在C语言中, 数组属于构造数据类型。一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不...

452100
来自专栏Java帮帮-微信公众号-技术文章全总结

Java面试系列12

一、排序都有哪几种方法?请列举。用JAVA实现一个快速排序。 排序的方法有: 插入排序(直接插入排序、希尔排序), 交换排序(冒泡排序、快速排序), 选择排序...

33460
来自专栏赵俊的Java专栏

Python 函数

43740
来自专栏测试开发架构之路

C++之类和对象的特性

简介:C++并不是一个纯粹的面向对象的语言,而是一种基于过程和面向对象的混合型的语言。 凡是以类对象为基本构成单位的程序称为基于对象的程序,再加上抽象、封装、...

37360
来自专栏yl 成长笔记

工厂模式

14830
来自专栏java一日一条

常见Java面试题 – 第四部分:迭代(iteration)和递归(recursion)

A. 可重入方法(re-entrant method)是可以安全进入的方法,即使同一个方法正在被执行,深入到同一个线程的调用栈里面也不会影响此次执行的安全性。一...

18120
来自专栏漫漫前端路

巧用 TypeScript(三)

我们期望它会如预想时那样工作,可是事与愿违,Promise.all(requestList),会出现类型兼容性的报错,在这个 Issues 里,描述了相同的问题...

15020
来自专栏赵俊的Java专栏

由一道 Java finally 执行顺序的题引发的思考

24440
来自专栏Linyb极客之路

JVM 方法内联

调用某个函数实际上将程序执行顺序转移到该函数所存放在内存中某个地址,将函数的程序内容执行完后,再返回到转去执行该函数前的地方。

26740
来自专栏华章科技

新手上路必学的Python函数基础知识,全在这里了(多段代码举例)

导读:函数是Python中最重要、最基础的代码组织和代码复用方式。根据经验,如果你需要多次重复相同或类似的代码,就非常值得写一个可复用的函数。通过给一组Pyth...

14520

扫码关注云+社区

领取腾讯云代金券