Java中的异常

• Java发现不正常的情况都包含着一些常见信息，并将这些信息进行了对象的封装。
• 异常这种机制，其实就是java按照面向对象的思想将出现的问题封装成了对象。
• 在进行问题分析时，发现问题有很多种，但是不断向上抽取，最终问题可以归纳为两种，一种是可以针对处理的（Exception），一种是通常不进行处理的（Error）。并且所有的异常都是由Throwable继承而来

异常（Exception）可以分为以下异常：

RuntimeException（由程序错误造成的异常，运行时检查）

1） 错误的类型转换

2） 数组访问越界

3） 访问NULL指针

IOException（外部资源等造成的异常，编译时检查）

1） 试图在文件尾部后面读取数据

2） 试图打开一个不存在的数据

3） 试图根据给定的字符长查找Class对象，而这个字符串表示的对象并不存在

RuntimeException

1. ArithmeticException：数学计算异常

2. NullPointerException：空指针异常

3. NegativeArraySizeException：负数组长度异常

4. ArrayIndexOutOfBoundsException：数组索引越界异常

5. ClassNotFoundException：类文件未找到异常

6. ClassCastException：造型异常

IOException

1. FileNotFoundException：文件未找到异常

2. EOFException：读写文件尾异常

3. MalformedURLException：URL格式错误异常

4. SocketException：Socket异常

从上面会发现：其子类的名称的后缀名都是父类名。

异常的层次结构图：

Java异常处理机制

1. Java程序的执行过程中如出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。
2. 当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获(catch)异常。
3. 如果Java运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出
4. 序员通常只能处理违例(Exception)，而对错误(Error)无能为力。

以下情况应该抛出异常：
1）调用一个受查异常的方法时，例如，FileInputStream构造器
2）序运行过程中发生错误，并且利用throw语句抛出一个受审查的异常
3）程序出错。例如，array[-1]=1;会抛出一个ArrayIndexOutOfBoundsException的非受

异常处理语句：

try{

        // 可能会抛出特定异常的代码段

}catch(MyExceptionType 
myException){

        // 如果myException被抛出，则执行这段代码

}catch(Exception otherException){

//如果另外的异常otherException被抛出，则执行这段代码

} [finally{

        //无条件执行的语句

}]

注意：
1.在try中某一行代码出现异常，在try中该行代码后的代码都将不被执行。
2.Try里面的语句不要过大
3.Try里面需要放可能出现问题的代码。
4.Catch接受异常时需要有一定的层次，即从上面到下面抛出的异常需要从小到大

try-catch-finally

try将可能出现异常的代码都放在try代码块中，当然，也可以将其他的一些不会引起异常的代码也一并放到try代码块中
 catch 从句中引入一个可能出现的异常，一个try块可以和多个catch块配合以处理多个异常
 当try块内的任何代码抛出了由catch 子句指定的异常，则try代码端中的程序将会终止执行，并跳到相应的catch代码块中来执行
 无论是否出现异常，程序最后都会执行finally代码块中的内容

Throw 和throws的区别：

Throws：跟在方法声明后，声明异常。用于声明函数的可能出现的问题，后面跟异常类，可以跟多个，用逗号隔开
Throw:后面需要跟异常对象，抛出异常。定义在函数内，用于抛出异常对象，后面跟的是异常对象

代码示例：

java.io.*;
public class ExceptionExam {
    public static void main(String[] args) 
        int a = 12;
        int b = 6;
        int c = 0;
        try {
           // throw newFileNotFoundException("c:\a.txt
           // (系统找不到指定的文件。)");虚拟机需要做的事情
           FileInputStream fin = new FileInputStream("c:/a1.txt");
           System.out.println("我运行了");//通过结果回发现上面的语句异常，而后面的语句没有执行
           int cc;
           // throw new ArithmeticException("/byzero");虚拟机需要做的事情
           a = b / c;
           byte[] buf = new byte[200];
           while ((cc = fin.read(buf)) != -1) {
               for (int i = 0; i < cc; i++) {
                   System.out.print((char) buf[i]);
               }
           }
        }
        // Catch接受异常时需要有一定的层次，即从上面到下面抛出的异常需要从小到大。
        // 如果在这里先接受Exception异常那么后面的异常就将无意义。并且编译不通过
        //应该注意的是：
        //      子类要处理比父类更多的方法。即子类不能不处理比父类更多的异常。
        //      异常是在编译或运行时期发生的不正常情况，在编译时就对其进行提供处理方案。
        // catch(Exception e){
        // System.out.println("读取文件出错！");
        // }
        catch (FileNotFoundException e) {
           System.out.println("message:" + e.getMessage());
           System.out.println("文件不存在！");
        } catch (EOFException e) {
           System.out.println("读写文件尾异常！");
        } catch (IOException e) {
           System.out.println("读取文件出错！");
        }
        catch (ArithmeticException e) {
           System.out.println("message:" + e.getMessage());
           System.out.println("算数异常：除数为零");

        } catch (Exception e) {
           System.out.println("读取文件出错！");
        }
        // try里面的语句出错抛出异常，不会影响try-catch后面的语句
        c = a * b;
        System.out.println("a*b=" + c);
    }
}

注意：如果在try语句中的任何代码抛出了一个catch子句中说明的异常类，那么
1) 程序将跳过try语句块的其余代码。
2) 程序将执行catch子句中的处理器代码。
3) 如果在try语句中的代码没有抛出任何异常，那么程序将跳过catch子句。
4) 如果方法中的任何代码抛出了一个在catch子句中没有的申明的异常类型，那么这个方法回立即退出（希望调用者为这种类型的异常设计catch子句）