AboutException的测试：
1 package test;
2 import javax.swing.*;
3
4 class AboutException {
5 public static void main(String[] a)
6 {
7 @SuppressWarnings("unused")
8 int i=1, j=0, k;
9 //System.out.println("第一次直接对两个整数进行除法运算结果：");
10 //k=i/j;
11
12
13 try
14 {
15 System.out.println("第五次测试finally语句在没有报错的前提下以及提前退出语句下是否会被执行：");
16 //System.out.println("第二次将两个整数放在try{}catch{}函数中进行除法运算结果：");
17 k = i/j; // Causes division-by-zero exception
18 //throw new Exception("Hello.Exception!");
19 //System.out.println("第三次测试finally语句在没有报错的情况下是否会被执行：");
20
21 }
22
23
24
25 catch (Exception e)
26 {
27
28 System.out.println(e.getMessage());
29 System.exit(0);
30
31 }
32
33
34 finally
35 {
36 JOptionPane.showConfirmDialog(null,"OK");
37 }
38
39 }
40 }
1.第一次
因为0不能作为分母而报错。
第二次
可以看到在try{}catch{}函数中虽然没有报错，但运算结果是将报错信息输出：/ by zero，
可以看出try{} catch{}函数的作用，还可以看到错误的信息。
第三次
可以看到，在程序没有报错的情况下，finally任然会被执行。
第四次
可以看到，在报错的前提下，加入提前退出语句后只输出了错误信息，而没有执行finally语句。
第五次
可以看到，在没有报错的前提下，catch语句不能正常执行，所以提前退出语句不执行，finally语句得以正常执行。
综上所述，有
（1）Finally语句不管有没有异常发生，finally语句都得以运行，但是在遇到提前退出语句后不能被执行。
（2）try{}catch{}函数能将错误信息抛出.
ThrowDemo的测试：
1 package test;
2 public class ThrowDemo {
3 public static void main(String[] args) {
4 // try {
5 double data = 100 / 0.0;
6 System.out.println("浮点数除以零：" + data);
7 // if(String.valueOf(data).equals("Infinity"))
8 // {
9 // System.out.println("In Here" );
10 // throw new ArithmeticException("除零异常");
11 // }
12 // }
13 // catch(ArithmeticException e) {
14 // System.out.println(e);
15 // }
16 }
17 }
181.第一次测试
没有报错，但是如果将0.0改为0就会有如下结果：
这个错误相比不是很陌生了，因为在上一个测试中我们遇到了无数次这个错误类型，就是因为分母为零，根据Java对double的定义运算，结果为无限。
2.第二次测试
系统抛出新的错误被截取，
3.第三次测试
错误被截取后正常输出。
在这个测试里，第二个catch没有被编译执行。
CatchWho测试：
1 package test;
2 public class CatchWho {
3 public static void main(String[] args) {
4 try { //2
5 try { //1
6 throw new ArrayIndexOutOfBoundsException();
7 }
8 catch(ArrayIndexOutOfBoundsException e) {
9 System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");
10 }
11
12 throw new ArithmeticException(); //扔出新的错误
13 }
14 catch(ArithmeticException e) {
15 System.out.println("发生ArithmeticException");
16 }
17 catch(ArrayIndexOutOfBoundsException e) { //没有输出，因为前面有一个catch将错误捕捉，这个就不会被执行了
18 System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");
19 }
20 }
21 }
测试结果
抛出错误类型。
CatchWho2测试：
1 package test;
2 public class CatchWho2 {
3 public static void main(String[] args) {
4 try {
5 try { //第一次扔出错误
6 throw new ArrayIndexOutOfBoundsException();
7 }
8 catch(ArithmeticException e) {//截取错误，但没有输出
9 System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");
10 }
11 throw new ArithmeticException(); //第二次扔出错误
12 }
13 catch(ArithmeticException e) { //不是正确的错误类型，错误类型不匹配，不输出
14 System.out.println("发生ArithmeticException");
15 }
16 catch(ArrayIndexOutOfBoundsException e) { //截取错误类型
17 System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");
18 }
19 }
20 }EmbededFinally测试;
1 package test;
2 public class EmbededFinally {
3
4
5 public static void main(String args[]) {
6
7 int result;
8
9 try {
10 //result=100/0;
11 System.out.println("in Level 1");
12
13
14 try {
15 result=100/0;
16 System.out.println("in Level 2");
17 // result=100/0; //Level 2
18
19 try {
20
21 System.out.println("in Level 3");
22
23 result=100/0; //Level 3
24
25 }
26
27 catch (Exception e) {
28
29 System.out.println("Level 3:" + e.getClass().toString());
30
31 }
32
33
34 finally {
35
36 System.out.println("In Level 3 finally");
37
38 }
39
40
41 // result=100/0; //Level 2
42
43
44 }
45
46 catch (Exception e) {
47
48 System.out.println("Level 2:" + e.getClass().toString());
49
50 }
51 finally {
52
53 System.out.println("In Level 2 finally");
54
55 }
56
57 // result = 100 / 0; //level 1
58
59 }
60
61 catch (Exception e) {
62
63 System.out.println("Level 1:" + e.getClass().toString());
64
65 }
66
67 finally {
68
69 System.out.println("In Level 1 finally");
70
71 }
72
73 }
74
75 }测试结果：
总结：
当有多层嵌套的finally时，异常在不同的层次抛出，在不同的位置抛出，可能会导致不同的finally语句块执行顺序。
来源：oschina
链接：https://my.oschina.net/u/4371026/blog/4152242