1 package cn.temptation;
2
3 public class Sample01 {
4 public static void main(String[] args) {
5 /*
6 * 异常：Java程序在运行过程中出现的错误
7 *
8 * 类 Throwable：Java 语言中所有错误或异常的超类。
9 * 只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
10 * 类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。
11 *
12 * 类 Error：Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
13 * 大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。
14 *
15 * 类 Exception：Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
16 *
17 * 异常的分类：
18 * 1、编译时异常：Exception类中除去RuntimeException及其子类以外其他的
19 * 2、运行时异常：RuntimeException及其子类
20 *
21 * 异常的处理方式：
22 * 1、try...catch...finally格式及其变体
23 * 2、throws/throw
24 *
25 * try...catch...finally处理方式：
26 * try {
27 * 可能出现问题的代码
28 * } catch(异常名称 变量) {
29 * 针对问题的处理
30 * } finally {
31 * 释放资源等操作
32 * }
33 *
34 * try...catch...finally处理的变体方式：
35 * try {
36 * 可能出现问题的代码
37 * } catch(异常名称 变量) {
38 * 针对问题的处理
39 * }
40 */
41
42 // 下句语句编译阶段无语法错误，但是执行时产生异常，这个异常不是由开发人员来处理，应该由开发人员编写代码时就进行判断处理
43 // System.out.println(2 / 0);
44
45 // 【针对单个异常】
46 // try {
47 // System.out.println(2 / 0);
48 // } catch (ArithmeticException e) {
49 // System.out.println("除数不能为0");
50 // }
51
52 // 【针对多个异常】
53 int[] arr = { 1, 2, 3 };
54
55 // try {
56 // // 如果没有进行异常处理，执行时，首先JVM捕获数组越界异常
57 // System.out.println(arr[3]);
58 // System.out.println(2 / 0);
59 // } catch (ArrayIndexOutOfBoundsException e) {
60 // System.out.println("数组的索引越界");
61 // } catch (ArithmeticException e) {
62 // System.out.println("除数不能为0");
63 // }
64
65 // 上述的异常处理代码会显示"数组的索引越界"，因为代码的顺序执行，首先捕获到索引越界异常，如果解决掉这个问题，再执行会捕获到除数为0的异常
66
67 // try {
68 // System.out.println(arr[3]);
69 // System.out.println(2 / 0);
70 // } catch (Exception e) {
71 // System.out.println("代码有问题");
72 // }
73
74 // 上述的异常处理代码使用异常基类Exception类，这样不用明确指出是哪一种异常（偷懒写法）
75
76 // 【JDK 1.7之后开始支持的语法】
77 try {
78 System.out.println(arr[3]);
79 System.out.println(2 / 0);
80 } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
81 System.out.println("代码有问题");
82 }
83
84 // 上述的异常处理代码需要多个异常是针对同一类类型的问题，否则无法明确具体是什么异常
85 }
86 }
1 package cn.temptation;
2
3 public class Sample02 {
4 public static void main(String[] args) {
5 /*
6 * 对异常的两种处理方式的理解：
7 * 类比生病
8 * 1、哪里有病了哪里疼痛，直接就在对应的问题就发现问题
9 * 2、有病的地方并不是病因产生的地方，而是病状呈现的地方，也就是问题不断抛出最后得到的结果
10 */
11
12 // try...catch...finally处理时的注意问题：
13 // 1、同时使用父类异常 和 子类异常时，父类异常不能写在子类异常之前，否则有语法错误
14 // try {
15 // System.out.println(2 / 0);
16 // } catch (Exception e) {
17 // System.out.println("代码有问题");
18 // } catch (ArithmeticException e) {
19 // // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
20 // System.out.println("除数不能为0");
21 // }
22
23 // 下面语句执行时显示子类异常信息
24 try {
25 System.out.println(2 / 0);
26 } catch (ArithmeticException e) {
27 // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
28 System.out.println("除数不能为0");
29 } catch (Exception e) {
30 System.out.println("代码有问题");
31 }
32 }
33 }
1 package cn.temptation;
2
3 public class Sample03 {
4 public static void main(String[] args) {
5 /*
6 * Throwable类的常用成员方法：
7 * 1、String getMessage() ：返回此 throwable 的详细消息字符串。
8 * 2、String toString() ：返回此 throwable 的简短描述。
9 * 3、void printStackTrace() ：将此 throwable 及其追踪输出至标准错误流。
10 */
11
12 try {
13 System.out.println(2 / 0);
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 at cn.temptation.Sample03.main(Sample03.java:13)
18 }
19 }
20 }
1 package cn.temptation;
2
3 public class Sample04 {
4 public static void main(String[] args) {
5 /*
6 * throws 关键字的使用：
7 * 定义方法时，使用throws关键字标记需要暴露出来被开发人员处理的问题
8 */
9
10 // 下句语句对calc方法的调用，因为在主函数中没有对calc方法抛出的异常进行处理，所以异常还是由jvm进行捕获
11 // 调用calc方法，收到其抛出的异常，没有进行处理
12 // calc();
13
14 try {
15 // 调用calc方法，收到其抛出的异常，并进行处理
16 calc();
17 } catch (ArithmeticException e) {
18 System.out.println("除数不为0");
19 }
20 }
21
22 // 在方法内部对异常不进行处理，在方法的声明上通过throws标记需要处理的异常，并向外抛出
23 // 定义计算方法
24 public static void calc() throws ArithmeticException {
25 System.out.println(2 / 0);
26 }
27 }
1 package cn.temptation;
2
3 public class Sample05 {
4 public static void main(String[] args) {
5 /*
6 * throw关键字的使用：
7 * 用在方法内部，出现某种情况程序无法继续运行时，需要进行跳转通过throw把异常对象进行抛出
8 *
9 *
10 * throws 和 throw 的区别：
11 * 1、throws
12 * A：用在方法声明中，后面是异常类名
13 * B：throws后可以有多个异常类名，之间使用英文逗号分隔
14 * C：表示抛出异常，由方法的调用者进行处理
15 * D：throws表示出现异常的可能，不一定会发生这些异常
16 *
17 * 2、throw
18 * A：用在方法内，后面是异常类的对象
19 * B：throw后只能抛出一个异常对象
20 * C：表示抛出异常，由方法内的语句处理，方法被调用时，调用方法处进行捕获处理
21 * D：throw表示抛出异常，执行throw一定是抛出了某种异常
22 */
23
24 // 使用throw关键字，在方法中抛出异常的实例对象，方法调用时没有语法错误
25 // calc();
26
27 // 下面代码捕获到ArithmeticException异常，并执行catch代码块的处理
28 // try {
29 // calc();
30 // } catch (ArithmeticException e) {
31 // System.out.println("计算异常");
32 // }
33
34 // 方法声明上throws出的异常 和 方法内throw出的异常是父子关系，必须进行异常处理，否则就语法出错
35 // method1();
36
37 // try {
38 // method1();
39 // } catch (Exception e) {
40 // System.out.println("除数不为0");
41 // }
42
43 // 方法声明上throws出的异常 和 方法内throw出的异常同级且不相同，以throw出的异常为准
44 method2();
45 }
46
47 // 声明计算方法
48 public static void calc() {
49 int i = 2;
50 int j = 0;
51
52 if (j == 0) { // 判断除数是0
53 throw new ArithmeticException();
54 } else {
55 System.out.println(i / j);
56 }
57 }
58
59 public static void method1() throws Exception {
60 int i = 2;
61 int j = 0;
62
63 if (j == 0) { // 判断除数是0
64 throw new ArithmeticException();
65 } else {
66 System.out.println(i / j);
67 }
68 }
69
70 public static void method2() throws ArrayIndexOutOfBoundsException {
71 int i = 2;
72 int j = 0;
73
74 if (j == 0) { // 判断除数是0
75 throw new ArithmeticException();
76 } else {
77 System.out.println(i / j);
78 }
79 }
80 }
1 package cn.temptation;
2
3 public class Sample06 {
4 public static void main(String[] args) {
5 /*
6 * 两种异常处理方式的选择：
7 * 1、如果在方法内部进行处理，选择try...catch...finally结构
8 * 2、如果在方法外部进行处理，选择throws/throw
9 *
10 * finally的特点：finally中的语句一定会被执行
11 * 注意：在执行finally语句块之前虚拟机终止了，那么finally语句块中的语句不会执行
12 */
13
14 try {
15 System.out.println(2 / 0);
16 } catch (Exception e) {
17 System.out.println("异常处理");
18 /*
19 * System类的常用成员方法：
20 * static void exit(int status) ：终止当前正在运行的 Java 虚拟机。
21 */
22 System.exit(0);
23 } finally {
24 System.out.println("finally中的语句一定会被执行");
25 }
26 }
27 }
1 package cn.temptation;
2
3 public class Sample07 {
4 public static void main(String[] args) {
5 // 在try...catch...finally...结构中使用return的问题：
6 // 1、catch语句块中有return语句，finally语句块中没有return语句，执行顺序为：
7 // 先执行catch语句块中return语句之前的语句，再执行finally语句块中的语句，最后执行catch中的return语句，显示结果为4
8 // 2、catch语句块中有return语句，finally语句块中也有return语句，执行顺序为：
9 // 先执行catch语句块中return语句之前的语句，再执行catch中的return语句，然后执行finally语句块中的语句，最后执行finally语句块中的return语句，显示结果为5
10 System.out.println(show());
11 }
12
13 public static int show() {
14 try {
15 System.out.println(2 / 0);
16 return 3;
17 } catch (Exception e) {
18 System.out.println("异常处理");
19 return 4;
20 } finally {
21 System.out.println("finally中的语句");
22 return 5;
23 }
24 }
25 }
1 package cn.temptation;
2
3 public class Sample08 {
4 public static void main(String[] args) {
5 // try...catch...finally...形式
6 // 完整形式
7 try {
8
9 } catch (Exception e) {
10
11 } finally {
12
13 }
14
15 // try...catch..（单个异常）
16 try {
17
18 } catch (Exception e) {
19
20 }
21
22 // try...catch..（多个异常）
23 try {
24
25 } catch (ArithmeticException e) {
26
27 } catch (Exception e) {
28
29 }
30
31 // try...finally...
32 // 没有catch代码块结构语法也正确，这种形式目的是为了使用后释放资源
33 try {
34
35 } finally {
36
37 }
38
39 // 语法错误
40 // try {
41 //
42 // }
43
44 // 语法错误
45 // catch (Exception e) {
46 //
47 // }
48
49 // 语法错误
50 // catch (Exception e) {
51 //
52 // } finally {
53 //
54 // }
55
56 // 语法错误
57 // finally {
58 //
59 // }
60 }
61 }
1 package cn.temptation;
2
3 public class Sample09 {
4 public static void main(String[] args) {
5 // 自定义异常类
6 try {
7 show(200);
8 } catch (TestException e) {
9 e.printStackTrace();
10 }
11 }
12
13 public static void show(int age) throws TestException {
14 if (age < 0 || age > 150) {
15 throw new TestException("年龄错误！");
16 } else {
17 System.out.println("年龄为：" + age);
18 }
19 }
20 }
21
22 /**
23 * 自定义异常类
24 */
25 class TestException extends Exception {
26 // 构造函数
27 public TestException() {
28
29 }
30
31 public TestException(String msg) {
32 super(msg);
33 }
34 }
