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

 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 }

 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 }