Java-try-catch-finally

  try-catch语句还可以包括第三部分，就是finally子句。它表示无论是否出现异常，都应当执行的内容。try-catch-finally语句的一般语法形式为：

 try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1) {  
    // 捕获并处理try抛出的异常类型Type1  
} catch (Type2 id2) {  
    // 捕获并处理try抛出的异常类型Type2  
} finally {  
    // 无论是否发生异常，都将执行的语句块  
}  

带finally子句的异常处理程序。

public class TestException {  
    public static void main(String args[]) {  
        int i = 0;  
        String greetings[] = { " Hello world !", " Hello World !! ",  
                " HELLO WORLD !!!" };  
        while (i < 4) {  
            try {  
                // 特别注意循环控制变量i的设计，避免造成无限循环  
                System.out.println(greetings[i++]);  
            } catch (ArrayIndexOutOfBoundsException e) {  
                System.out.println("数组下标越界异常");  
            } finally {  
                System.out.println("--------------------------");  
            }  
        }  
    }  
}  

运行结果：

Hello world !
--------------------------
Hello World !!
--------------------------
HELLO WORLD !!!
--------------------------
数组下标越界异常
--------------------------

 在例5中，请特别注意try子句中语句块的设计，如果设计为如下，将会出现死循环。如果设计为：

try {  
      System.out.println (greetings[i]); i++;  
}  

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：

1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。

 

 try-catch-finally 规则(异常处理语句的语法规则）：

1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
3) catch 块与相应的异常类的类型相关。
4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
5) 可嵌套 try-catch-finally 结构。
6) 在 try-catch-finally 结构中，可重新抛出异常。
7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。

 try、catch、finally语句块的执行顺序:

1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；

2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；

3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

测试finally执行影响情况

不影响返回结果，主要还是try中返回了，在后面只会执行一下finally，即使name改变也不会影响返回结果

    public static void main(String[] args) {
        System.out.println(get(""));
        
    }
    
    public static String get(String name) {
        try {
            System.out.println("try x"+name);
            name = name.toLowerCase()+"123456";

            System.out.println("try y"+name);
            return name;
        } catch (Exception e) {
            System.out.println("exception"+name);
        }finally {
            name = "----";
        }
        System.out.println("return"+name);
        return "```";
    }

结果

try x
try y123456
123456

会影响返回值的情况（本列测试，也正好测试了return返回的如果是对象的引用不是基本数据类型的数据的话，则finally中如果将对象中的内容改变，return中的内容也将会改变，也即是对象在内存中所指向的字符）

    public static void main(String[] args) {
        System.out.println(get(new StringBuilder()).toString());
        
    }
    
    public static StringBuilder get(StringBuilder name) {
        try {
            System.out.println("try x"+name);
            name.append("123456");

            System.out.println("try y"+name);
            return name;
        } catch (Exception e) {
            System.out.println("exception"+name);
        }finally {
            name .append("-----");
        }
        System.out.println("return"+name);
        return name;
    }

结果

try x
try y123456
123456-----

会影响返回值的情况（主要为finally中执行了return所以被迫影响到了try中的return）

    public static void main(String[] args) {
        System.out.println(get(""));
        
    }
    
    public static String get(String name) {
        try {
            System.out.println("try x"+name);
            name = name.toLowerCase()+"123456";

            System.out.println("try y"+name);
            return name;
        } catch (Exception e) {
            System.out.println("exception"+name);
        }finally {
            name = "----";
            System.out.println("finally"+name);
            return "这列";
        }
        //System.out.println("return"+name);
        //return "```";
    }

输出（从结果看很明显将原版返回123456的结果被finally的return返回了）

try x
try y123456
finally----
这列