Java-异常处理机制

异常简介

异常的定义
- 运行期间出现的错误，而不是编译时的语法错误
- 例如，
  - 打开一个不存在的文件
  - 网络连接中断
  - 操作数组越界等
异常的定义
- 示例 数组越界异常

public class excption_sample {
    public static void main(String args[ ]){
       int i = 0;
       String greetings[ ] = {"Hello World",
                                       "Hello Dingdang",
                                       "Hello Kitty"};

       while(i<4){
          System.out.println(greetings[i]);
          i++;
       }
    }
}

异常类的继承关系

异常的继承树

异常类的体系结构
Object 类的直接子类Throwable描述了所有被虚拟机抛出的非正常状况。一般情况下很少用Throwable，而是使用它的两个子类Error、Exception。
- Error类特指应用程序在运行期间发生的严重错误。如：虚拟机内存用尽、堆栈溢出等等。一般情况下这种错误都是灾难性的，所以没有必要使用异常处理机制处理Error。
- Exception类有几十个子类，描述了不同类型的异常，其中：
  - 以RuntimeException为代表的一些类，称为非检查性异常（unchecked Exception），
  - 以IOException为代表的一些类为检查性异常（checked Exception）。所谓的检查和非检查是指编译器在编译时是否检查。如果代码中存在检查性异常，必须进行异常处理，否则编译时不能通过；而非检查性异常编译时不进行检查，到运行时才会显现。
异常类型
- 检查性异常（checked exception）
  - 若系统运行时可能产生该类异常，则必须写出相应的处理代码，否则无法通过编译
  - 非RuntimeException异常
- 非检查性异常（unchecked exception）
  - 若系统运行时可能产生该类异常，则不必在程序中声明对该类异常的处理，就可以编译执行
  - RuntimeException：运行时异常
Java为何分别处理这两类异常？

一般我们不在代码中处理非检查性异常，这类异常都在运行时抛出。原因主要是由于程序员经验不足或是思维不缜密造成。如:数组越界异常（ArrayIndexOutOfBoundsException）、整数除以0异常（ArithmeticException）等，这类异常其实就是我们通常说的bug。所以，这类异常应通过反复测试尽量避免，而不应该靠异常处理机制来解决。

检查性异常不同，就算程序员再有经验，也是难以避免。如：用户连接数据库的异常（SQLException），如果是由于数据库服务器没有启动或是网络中断引起的，我们程序员是无法避免的。又如：程序要读取光盘中的文件，而用户忘记插入光盘，此时则抛出文件没找到异常（FileNotFoundException），程序员也无法避免。

综上，异常处理机制主要处理检查性异常而不是非检查性异常和Error。

非检查性异常	说明
RuntimeException	java.lang包中多数异常的基类
ArithmeticException	算术错误，如除以 0
IllegalArgumentException	方法收到非法参数
ArrayIndexOutOfBoundsException	数组下标出界
NullPointerException	试图访问 null 对象引用

检查性异常	说明
ClassNotFoundException	无法找到想要创建对象的类文件
IOException	I/O 异常的根类
FileNotFoundException	不能找到文件
EOFException	文件结束
IllegalAccessException	对类的访问被拒绝
NoSuchMethodException	请求的方法不存在
InterruptedException	线程中断

异常处理机制

异常的处理过程

在Java程序执行过程中如果出现异常事件，系统会发出异常报告，这时系统将生成一个异常类对象，异常类对象封装了异常事件的信息并将其提交给Java运行时系统
Java 中可用于处理异常的两种方式：
- 自行处理：可能引发异常的语句封入在 try 块内，而处理异常的相应语句则封入在 catch 块内。
- 回避异常：在方法声明中包含 throws 子句，通知潜在调用者，如果发生了异常，必须由调用者处理。
try…catch语句

示例 Exception_sample_1.java

public class excption_sample {
    public static void main(String args[ ]){
       int i = 0;
       String greetings[ ] = {"Hello World",
                            "Hello Dingdang",
                            "Hello Kitty"};
      try{  //try{}表示可能发生异常的语句     
          while(i<4){
             System.out.println(greetings[i]);
             i++;
          }
      }catch(ArrayIndexOutOfBoundsException e){//catch( )内的参数异常类对象的声明
             System.out.println(“数组越界异常”);//catch{}内的语句是对异常的处理
        }
      }
 }

catch块，是用来捕获并处理try块抛出的异常的代码块。没有try块，catch块不能单独存在。我们可以有多个catch块，以捕获不同类型的异常
如果程序抛出多个不同类型的异常，我们需要多个catch()语句来处理。
和特殊异常类相关联的catch()块必须写在和普通异常类相关联的catch()之前。
try{…}和catch( ){…}之间不可以添加任何代码

每次try块有异常抛出，系统会试着从上到下往每个catch块中传参，直到遇到一个类型匹配的catch块为止。
如上示例中最后一个catch块中的形参为Exception类型，它是所有异常类的父类，任何异常都可以传参到该块中，该块可以处理任何类型的异常。因此，这个catch块只能放到最后面，否则所有的异常都被它处理了，其他的catch块就不能分门别类的起作用了。
如果编写过程中我们违背了这一点，会产生编译错误：

exception java.io.ArrayOutOfBoundsException has already bean caught

一般一个catch块中是专门处理异常的代码，在程序中这里还可以是记录日志的语句，当发生异常时记录该日志，无异常时将不会记录。

异常处理机制——Java7特性

catch表达式调整
- JDK 7中，单个catch块可以处理多个异常类型

try {  
   ......  
   
} catch(ClassNotFoundException|SQLException ex) {  
    ex.printStackTrace();  
   
}

catch表达式调整
- 这种用法是不包括异常的子类型的。比如说，下面这个多个异常的捕获语句就会抛出编译错误：

try {   
   ......  
  
} catch (FileNotFoundException | IOException ex) {  
   ex.printStackTrace();  
}

finally 语句
- finally语句放在try …catch语句后
- fianlly语句中的代码块不管异常是否被捕获总是要执行

通常在finally语句中可以进行资源的清除操作，如：关闭打开文件、删除临时文件
对应finally代码中的语句，即使try代码块和catch代码块中使用了return语句退出当前方法或般若break跳出某个循环，相关的finally代码块都有执行。
当try或catch代码块中执行了System.exit(0)时，finally代码块中的内容不被执行

catch (ArrayIndexOutOfBoundsException e) {
   System.out.println(“Out of Bounds!”);
   return;
 }
catch (RuntimeException e) {
   System.out.println(“Runtime Exception!”);}
catch (Exception e) {
   System.out.println(“Exception!”); 
   }finally{
       System.out.println("program is running into finally!");//无论是否捕获异常，系统都会执行该语句
   }

throws关键字
- 如果一个方法中的语句执行时可能生成某种异常，但是并不能确定如何处理，则可以在程序所在的函数声明后，使用throws关键字抛出异常

class ThrowsDemo{
    public  void proc( ) throws IOException{
        System.out.println("inside proc");          
    }
}

位置：函数参数列表的后面
throws关键字后面，可以跟多个异常，中间用逗号分割
throws关键字抛出的异常，由调用该函数的函数处理。
方法中如果用throws关键字抛出：
- 非检查性异常：上一级去除异常，直到不抛出异常；
- 检查性异常
  - 在调用该函数内try-catch，把异常处理掉。那么不往上一级抛出异常，程序正常执行，上一级方法并不知道曾经产生异常。
  - 用throws声明方法抛出异常，不进行处理。谁调用谁负责处理
  - 覆盖方法抛出异常时，可以抛出与被覆盖方法相同的异常或者被覆盖方法异常的子类异常。

public class ThrowTest
{
    public void createFile(String path) throws IOException{
        File f= new File(path);
        f.createNewFile();
    }
    public static void main(String[] args){
        ThrowTest  tt = new ThrowTest();
        try{
            tt.createFile("c:/abc.txt");
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }
}

throw语句
- 异常是通过关键字 throw 抛出，程序可以用throw语句引发明确的异常。如：

void doA() throws Exception1 {
    try {
        .....
    }catch(Exception1 e){
        throw e;
    }catch(Exception2 e){
        System.out.println("出错了");
    }
}

throw语句用在方法体内,表示抛出异常,由方法体内的语句处理。不能单独使用，要么和try.. catch…一起使用，要么和throws一起使用。
throw语句的操作数一定是Throwable类类型或Throwable子类类型的一个对象

public class ThrowTest
{
    public void createFile(String path) throws IOException{
        File f= new File(path);
        try{
            f.createNewFile();
        }catch(IOException ie){
            ie.printStackTrace();
            throw ie;    //再次抛出
        }
    }
    public static void main(String[] args){
        ThrowTest  tt = new ThrowTest();
        try{
            tt.createFile("c:/abc.txt");
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }
}

示例代码：

package 异常的处理;

public class TestExceptionHandler {
    
    public int sum(int a,int b) {
        return a + b;
    }
    
    public static void main(String[] args) throws ClassNotFoundException {//2.消积处理

        //模拟异常，看怎么处理？
        
        //2.消积处理：异常抛出虚拟机，程序终止
        Class.forName("java.a.Date");
        
        //1.积极处理:程序继续执行完毕
//      try {
//          Class.forName("java.a.Date");
//      } catch (Exception e) {
//          e.printStackTrace();
//      }
//      for (int i = 0; i < 100; i++) {
//          System.out.println(i);
//      }

    }

}

package 异常的处理;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestExceptionHandler2 {
    
    public static void main(String[] args){

        File file = new File("e:\\HelloWorld.java");
        
        
        FileInputStream is = null;
        try {
            is = new FileInputStream(file);
            int result = is.read();//根据提示选择clause to surrounding by 
            
            
            Class.forName("java.a.b");
//      } catch (ClassNotFoundException | IOException e) {//Java7对catch的改写，可以多个异常同时写
//          e.printStackTrace();
        } catch (FileNotFoundException e) {
            System.out.println("a");
            e.printStackTrace();
        } catch (ClassNotFoundException e1) {

            e1.printStackTrace();
        } catch (IOException e) {
            System.out.println("b");
            e.printStackTrace();
//1.finally语句块有什么 作用？
//  用于释放资源，即使代码抛出异常，
//  finally语句块中的代码也会执行
        }finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
//2.final finalize finally 有什么区别？
/**
 * final 修饰的类不能有子类 
 *       修饰的方法不能重写 
 *       修饰的变量不能重新赋值，叫常量
 * finalize：如果发现有垃圾对象的话就会调用finalize()方法，释放它所占用的内存 
 * finally: 确保我们程序当中有些释放资源的方法能够执行，
 *          一般跟在try catch语句块后面      
 */

    }

}

package 异常的处理;

import java.io.File;
import java.io.FileInputStream;


public class TestRuntimeException {

    public static void main(String[] args) throws Exception {//消积处理
//      String a = null;
//      System.out.println(a.length());//java.lang.NullPointerException
        
        File file = new File("e:\\HelloWorld.java");
        
        
//      try {
//          FileInputStream is = new FileInputStream(file);
//          
//          int result = is.read();
//      } catch (Exception e) {
//          e.printStackTrace();
//      }//积极处理
        
        FileInputStream is = new FileInputStream(file);
        
        int result = is.read();
    }
}

package 异常的处理;

public class Test {

    public static void main(String[] args) {
        
//      double p = "";//这是语法错误，称不上异常
        /**
         * 异常：
         * 代码运行期间出现的错误
         * 打开一个不存在的文件
         * 网络连接中断
         * 操作数组越界等
         */
        
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
        
//      int b = 0;
//      if(b != 0) {
//          int a = 10 / b;
//      }
        
        try {
            Class.forName("java.a.b");
            System.out.println("a");
        } catch (Exception e) {
            System.out.println("b");
            e.printStackTrace();
        }finally {
            System.out.println("d");
        }
        
        System.out.println("c");
        
        
        
        for (int i = 0; i < 10; i++) {
            System.out.println("i: " + i);
        }
    }
}

以上就是我关于 Java-自定义异常类 知识点的整理与总结的全部内容，另附源码

==================================================================

分割线