try catch finally的一些用法

一：例题：

package test;

import javax.swing.*;

class AboutException {
   public static void main(String[] a)
   {
      int i=1, j=0, k;
    try
    {

        k = i/j;    // Causes division-by-zero exception
        //throw new Exception("Hello.Exception!");
    }

    catch ( ArithmeticException e)
    {
        System.out.println("被0除.  "+ e.getMessage());
    }
    finally
     {
             JOptionPane.showConfirmDialog(null,"OK");
     }

  }
}

其结果显示

被0除.  / by zero

总结：程序看下来，1/0在数学逻辑上是错误的，在计算机运行中肯定会报错，当编程过程中，有些地方不太能更彻底的了解漏洞在哪里，那么try和catch机制来最大化地挽留损失，以上程序中，try将可能发生错误的地方抛出，当执行发生错误了，计算机并不报错，而是有catch语句抓住，执行其中内容，后面还有个finally语句，用于善后的代码，不管是否有异常发生，finally语句块中的语句始终保证被执行.

二：例题：

package test;

public class CatchWho {
    public static void main(String[] args) {
        try {
            try {
                throw new ArrayIndexOutOfBoundsException();
            }
            catch(ArrayIndexOutOfBoundsException e) {
               System.out.println(  "ArrayIndexOutOfBoundsException" +  "/内层try-catch");
            }

            throw new ArithmeticException();
        }
        catch(ArithmeticException e) {
            System.out.println("发生ArithmeticException");
        }
        catch(ArrayIndexOutOfBoundsException e) {
           System.out.println(  "ArrayIndexOutOfBoundsException" + "/外层try-catch");
        }
    }
}

结果:

ArrayIndexOutOfBoundsException/内层try-catch
发生ArithmeticException

分析：

注意其结构，里面的try抛出异常一，对应的catch（紧跟着的catch）接收一并执行，外层的try抛出异常二，对应的catch接收二并执行，抛出异常和接收异常这执行可以看成是一个单一的动作操作，最后的catch就没有抛出这一动作执行，所以不运行（因为抛出异常一已被接住）。

看另一个例题：

package test;

public class CatchWho2 {
    public static void main(String[] args) {
        try {
            try {
                throw new ArrayIndexOutOfBoundsException();
            }
            catch(ArithmeticException e) {
                System.out.println( "ArrayIndexOutOfBoundsException" + "/内层try-catch");
            }
            throw new ArithmeticException();
        }
        catch(ArithmeticException e) {
            System.out.println("发生ArithmeticException");
        }
        catch(ArrayIndexOutOfBoundsException e) {
            System.out.println( "ArrayIndexOutOfBoundsException" + "/外层try-catch");
        }
    }
}

其结果为：

ArrayIndexOutOfBoundsException/外层try-catch

分析：

此例题和上面例题的区别就在于，里面的catch所接住的方向变了。

按着程序顺序分析下来，当里面的try抛出异常时，只有外面的catch能接住，那么开始执行外面的catch，顺序就从刚才执行的语句之下执行下去了，即便是外面的catch交换顺序，结果一样不变。

由两题总结：try catch这一模式，是有顺序依据的，当执行try语句是，紧接着的就是所对应的catch来执行，然后接着catch继续执行下去。

三：例题：

package test;

public class EmbededFinally {
    public static void main(String args[]) {
        int result;
        try {
            System.out.println("in Level 1");
             try {
                System.out.println("in Level 2");
  // result=100/0;  //Level 2
                 try {
                     System.out.println("in Level 3");
                     result=100/0;  //Level 3
                }
                catch (Exception e) {
                    System.out.println("Level 3:" + e.getClass().toString());
                }
                finally {
                    System.out.println("In Level 3 finally");
                }
                // result=100/0;  //Level 2
                }
            catch (Exception e) {
                 System.out.println("Level 2:" + e.getClass().toString());
             }
             finally {
                System.out.println("In Level 2 finally");
             }
            // result = 100 / 0;  //level 1
        }
        catch (Exception e) {
            System.out.println("Level 1:" + e.getClass().toString());
        }
        finally {
             System.out.println("In Level 1 finally");
        }
    }
}

结果：

in Level 1
in Level 2
in Level 3
Level 3:class java.lang.ArithmeticException
In Level 3 finally
In Level 2 finally
In Level 1 finally

总结：finally是无论是否出现异常都会执行的，在第三个try中出现异常，紧跟着的catch已经接收到，但此并不算第二个try出现异常，因为异常已经解决，那么之后就不会显示第二个和第一个catch的内容了。我将内容改了一下，就验证了我的说法。

try {
                System.out.println("in Level 2");
  // result=100/0;  //Level 2
                 try {
                     System.out.println("in Level 3");
                     result=100/0;  //Level 3
                }
                catch (ArrayIndexOutOfBoundsException e) {  //我让此catch不能捕捉到上面的try，有意让第二个catch抓到
                    System.out.println("Level 3:" + e.getClass().toString());
                }
                finally {
                    System.out.println("In Level 3 finally");
                }
                // result=100/0;  //Level 2
                }
            catch (Exception e) {//第二个catch
                 System.out.println("Level 2:" + e.getClass().toString());
             }
             finally {
                System.out.println("In Level 2 finally");
             }

结果显示

in Level 1
in Level 2
in Level 3
In Level 3 finally
Level 2:class java.lang.ArithmeticException
In Level 2 finally
In Level 1 finally

结论：try catch着一单一动作（前提是配套），就是出现异常和处理异常的程序，那总的来看，依旧是无异常的代码。

四：例题：

package test;

public class SystemExitAndFinally {

    public static void main(String[] args)
    {
        try{

            System.out.println("in main");
            throw new Exception("Exception is thrown in main");
            //System.exit(0);

        }
        catch(Exception e)
        {
            System.out.println(e.getMessage());
            System.exit(0);
        }
        finally
        {
            System.out.println("in finally");
        }
    }

}

结果：

in main
Exception is thrown in main

总结：

JVM是java虚拟机，finally是由JVM保证执行，而System.exit(0)是正常退出程序，结束JVM的运行，那么最后finally就不再执行。

PS:System.exit(status)不管status为何值都会退出程序,非0，则表示为非正常退出程序，一般放在catch块中，当捕获到异常，需要停止程序，用非0值来表示非正常退出程序