异常处理

1异常类的继承

1.try块里声明的变量是代码块内部局部变量，它只在try块内有效，在catch块中不能访问该变量。
2.异常(Exception)和错误(Error)两种，Exception可以被捕获，而Error错误，一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，动态链接失败等，这种错误无法捕获或无法恢复，故catcha是不能捕获到Error对象，也无须在其throws子句中声明该方法可能抛出Error及其任何子类，异常的继承图：

3.进行异常捕获时不仅应该把Exception类对应的catch块放在最后，而且所有的父类异常的catch块都应该排在子类异常catch块的后面(遵循先处理小异常，再处理大 异常)
4.捕获多种类型的异常时，多中异常类型之间用竖线(|)隔开，异常变量有隐式的final修饰，因此程序不能对异常变量重新赋值
代码例子：

public class MultiExceptionTest{    public static void main(String[] args)     {        try        {            int a = Integer.parseInt(args[0]);            int b = Integer.parseInt(args[1]);            int c = a / b;            System.out.println("您输入的两个数相除的结果是：" + c );        }        catch (IndexOutOfBoundsException|NumberFormatException            |ArithmeticException ie)        {            System.out.println("程序发生了数组越界、数字格式异常、算术异常之一");            // 捕捉多异常时，异常变量默认有final修饰，            // 所以下面代码有错：            ie = new ArithmeticException("test");  //①        }        catch (Exception e)        {            System.out.println("未知异常");            // 捕捉一个类型的异常时，异常变量没有final修饰            // 所以下面代码完全正确。            e = new RuntimeException("test");    //②        }    }} 

5.异常处理语法结构中只有try块是必需，而catch和finally是可选的(但必需catch和finally块至少出现其中之一)，catch如果有return语句，在执行return语句之前，程序还会执行finally块，但如果catch如果有System.exit(1)语句，则不会执行finally块。
代码例子：

public class FinallyTest{    public static void main(String[] args)     {        FileInputStream fis = null;        try        {            fis = new FileInputStream("a.txt");        }        catch (IOException ioe)        {            System.out.println(ioe.getMessage());            //return语句强制方法返回,会执行下面的finally            return ;       //①            //使用exit来退出虚拟机，不会执行下面的finally            //System.exit(1);     //②        }        finally        {            //关闭磁盘文件，回收资源            if (fis != null)            {                try                {                    fis.close();                }                catch (IOException ioe)                {                    ioe.printStackTrace();                }            }            System.out.println("执行finally块里的资源回收!");        }    }}

6.不要在finally块中使用如return或throw等导致方法终止的语句，一旦在finally快中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效。
代码例子：

public class FinallyFlowTest{    public static void main(String[] args)        throws Exception    {        boolean a = test();        System.out.println(a);    }    public static boolean test()    {        try        {            // 因为finally块中包含了return语句            // 所以下面的return语句失去作用            return true;        }        finally        {            return false;        }    }}

7.java7以后,允许try关键字后紧跟一对圆括号(这里try语句相当于包含了隐式的finally，所以后面不需要有catch和finally块)，圆括号里可以声明，初始化一个或多个资源，此处的资源指的是那些必须在程序结束时显示关闭的资源(比如数据库连接，网络连接)，try语句在该语句结束时会自动关闭这些资源(这些资源实现类必须实现AutoCloseable或Closeable接口)
代码例子：

public class AutoCloseTest{    public static void main(String[] args)         throws IOException    {        try (            // 声明、初始化两个可关闭的资源            // try语句会自动关闭这两个资源。            BufferedReader br = new BufferedReader(                new FileReader("AutoCloseTest.java"));            PrintStream ps = new PrintStream(new                FileOutputStream("a.txt")))        {            // 使用两个资源            System.out.println(br.readLine());            ps.println("庄生晓梦迷蝴蝶");        }    }}

2Checked异常和Runtime异常体系

1.Checked异常需要程序显示处理(一般是通过try…catch)，否则程序会产生编译错误，而Runtime异常则不要程序显示处理。
代码例子：

public class Test{    public static void g() throws RuntimeException    {        String a=null;    }       public static void t() throws Exception    {        String a=null;    }    public static void main(String[] args)     {        //编译通过,因为异常是UnChecked类型        g();        //编译不通过,因为异常是Checked类型        //要么用try，要么用throws，编译才能通过        t();    }}

3使用throw抛出异常

1.throw语句常用于catch代码快中，其抛出的不是异常类，而是异常实例，且只能抛出一个异常实例。
2用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承RuntimeException基类，一般需要提供两个构造器：一个是无参数的构造器，另一个是带一个字符串参数的构造器。
代码例子：

public class AuctionException extends Exception{    //无参数的构造器    public AuctionException(){}       //①    //带一个字符串参数的构造器    public AuctionException(String msg)    //②    {        super(msg);    }}

3.java7以后，Java编译器会执行更细致的检查，Java编译器会检查throw语句抛出异常的实际类型
代码例子：

public class ThrowTest2{    public static void main(String[] args)        // Java 6认为①号代码可能抛出Exception，        // 所以此处声明抛出Exception//      throws Exception        // Java 7会检查①号代码可能抛出异常的实际类型，        // 因此此处只需声明抛出FileNotFoundException即可。        throws FileNotFoundException    {        try        {            new FileOutputStream("a.txt");        }        catch (Exception ex)        {            ex.printStackTrace();            throw ex;        //①        }    }}

4.捕获一个异常然后接着抛出另一个异常，并把原始信息保存下来，这种典型的链式处理被称为“异常链”，JDK1.4以后，所有Throwable的子类在构造器中都可以接受一个cause对象作为参数，而这个cause就来表示原始异常。
代码例子：
第一种不使用异常链处理：

public class Test{    public static void g()    {        try        {            String a=null;            System.out.println(a.length());        }         catch (Exception e)        {                       throw new RuntimeException();        }    }       public static void main(String[] args)     {        System.out.println("g()方法异常信息");        g();            }}

运行结果：
**g()方法异常信息
Exception in thread main java.lang.RuntimeException**
第二种使用异常链处理：

public class Test{    public static void t()    {        try        {            String a=null;            System.out.println(a.length());        }         catch (Exception e)        {                       throw new RuntimeException(e);        }    }       public static void main(String[] args)     {        System.out.println("t()方法异常信息");        t();            }}

运行结果：
**Exception in thread main java.lang.RuntimeException: java.lang.NullPointerException
Caused by: java.lang.NullPointerException**
比较这两种的运行结果了，可以看出，异常链式处理打印出了最原始的异常信息，而非异常链式处理只打印最后一个抛出的异常信息。

4Java的异常跟踪栈

1. 异常的传播规则：只要异常没有被完全捕获(包括异常没有被捕获，或异常被处理后重新抛出了新异常),异常从发生异常的方法逐渐向外传播，首先传给该方法的调用者，该方法调用者再次传给其调用者…….
代码例子：

class SelfException extends RuntimeException{    SelfException(){}    SelfException(String msg)    {        super(msg);    }}public class PrintStackTraceTest{    public static void main(String[] args)    {        firstMethod();    }    public static void firstMethod()    {        secondMethod();    }    public static void secondMethod()    {        thirdMethod();    }    public static void thirdMethod()    {        throw new SelfException("自定义异常信息");    }}

运行结果：
**Exception in thread ‘main’ csdn1.SelfException: 自定义异常信息
at csdn1.PrintStackTraceTest.thirdMethod(PrintStackTraceTest.java:27)
at csdn1.PrintStackTraceTest.secondMethod(PrintStackTraceTest.java:23)
at csdn1.PrintStackTraceTest.firstMethod(PrintStackTraceTest.java:19)
at csdn1.PrintStackTraceTest.main(PrintStackTraceTest.java:15)**
这篇博客参考资料
Java疯狂讲义2