java笔记--java异常处理机制，

java笔记--java异常处理机制，

1、异常的概念与体系结构
异常指程序的各种不正常状况，如文件读写异常，网络异常，非法参数异常等。异常发生在程序运行过程中，干扰程序的
正确执行。java的所有异常都继承自Throwable，java把一系列的异常封装成对象，如下是Java的异常体系结构。
Throwable
  |--Error
     |--VirtualMachineError
     |--AwtError
  |--Exception
     |--RunTimeException
        |--ArrithmeticException
|--ArrayIndexOutOfBoundException
|--NullPointerException
|--IllegalArgumentException
|--......

     |--IOException
|--FileNotFoundException
|--EOFException
|--......
Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，
各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，
而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（VirtualMachineError），
当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
Exception（异常）:是程序本身可以处理的异常。 Exception 类有一个重要的子类 RuntimeException。
例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
RunTimeException及其子类以及Error是不可检查异常，这类异常编译器不会强制要求程序员处理，而其他异常，如IOException是可检查异常，java编译器会检查它，如果程序员不进行处理
（要么try要么抛）将不能通过编译。


运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，
也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。
非运行时异常 （编译异常）：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。
如IOException、SQLException等以及用户自定义的Exception异常。


2、异常的处理方式
（1）抛给调用者
如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，
则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。
如：
method() throws Exception1,Exception2,...
{


}
方法名后的throws Exception1,Exception2,...为声明要抛出的异常列表。当方法抛出异常列表的异常时，该方法将不对这些类型及其子类类型的异常作处理，而抛向调用者，如果调用者依然无法处理异常，
它也可以选择继续抛。但最终要有可以处理该异常的调用者。
例子：
import java.lang.Exception;  
public class TestException {  
    static void pop() throws NegativeArraySizeException {  
        // 定义方法并抛出NegativeArraySizeException异常  
        int[] arr = new int[-3]; // 创建数组  
    }  
  
    public static void main(String[] args) { // 主方法  
        try { // try语句处理异常信息  
            pop(); // 调用pop()方法  
        } catch (NegativeArraySizeException e) {  
            System.out.println("pop()方法抛出的异常");// 输出异常信息  
        }  
    }   
} 


（2）捕获异常
在java中也可以不抛异常，而是选择自己捕获。捕获异常使用try-catch语句块。其一般语法形式为：
try 
{  
    // 可能会发生异常的程序代码  
} 
catch (Type1 id1)
{  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2)
{  
     //捕获并处置try抛出的异常类型Type2  
}  
匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，
则认为生成的异常对象与catch块捕获的异常类型相匹配。
例子：
public class TestException {  
    public static void main(String[] args) {  
        int a = 6;  
        int b = 0;  
        try { // try监控区域  
            System.out.println("a/b的值是：" + a / b);  
        }  
        catch (ArithmeticException e) { // catch捕捉异常  
            System.out.println("程序出现异常，变量b不能为0。");  
        }  
        System.out.println("程序正常结束。");  
    }  
} 
 需要注意的是，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。
其他的catch子句不再有匹配和捕获异常类型的机会。因此对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，
同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽。
try-catch语句还可以包括第三部分，就是finally子句。它表示无论是否出现异常，都应当执行的内容。try-catch-finally语句的一般语法形式为：
try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1) {  
    // 捕获并处理try抛出的异常类型Type1  
} catch (Type2 id2) {  
    // 捕获并处理try抛出的异常类型Type2  
} finally {  
    // 无论是否发生异常，都将执行的语句块  
} 


小结：


try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。 


3、使用throw抛自定义异常
throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。
我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：
    throw new exceptionname;
    例如抛出一个IOException类的异常对象：
    throw new IOException;
    要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象，因此如果要自定义异常，则需要继承Throwable或者其子类。下面的操作是错误的：
    throw new String("exception");
    这是因为String 不是Throwable 类的子类。
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。
如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
例子：
package Test;  
import java.lang.Exception;  
public class TestException {  
    static int quotient(int x, int y) throws MyException { // 定义方法抛出异常  
        if (y < 0) { // 判断参数是否小于0  
            throw new MyException("除数不能是负数"); // 异常信息  
        }  
        return x/y; // 返回值  
    }  
    public static void main(String args[]) { // 主方法  
        int  a =3;  
        int  b =0;   
        try { // try语句包含可能发生异常的语句  
            int result = quotient(a, b); // 调用方法quotient()  
        } catch (MyException e) { // 处理自定义异常  
            System.out.println(e.getMessage()); // 输出异常信息  
        } catch (ArithmeticException e) { // 处理ArithmeticException异常  
            System.out.println("除数不能为0"); // 输出提示信息  
        } catch (Exception e) { // 处理其他异常  
            System.out.println("程序发生了其他的异常"); // 输出提示信息  
        }  
    }  
  
}  
class MyException extends Exception { // 创建自定义异常类  
    String message; // 定义String类型变量  
    public MyException(String ErrorMessagr) { // 父类方法  
        message = ErrorMessagr;  
    }  
  
    public String getMessage() { // 覆盖getMessage()方法  
        return message;  
    }  
}