异常处理

java中异常体系

异常：java程序中存在某些不正常的情况。

异常体系图：

通过上图基本可以了解java中异常体系的分类和继承关系：

异常体系：
-------| Throwable 异常和错误的超类
-----------| Errow 错误：一般是由于jvm或者硬件引发的问题，一般不会通过代码来处理。
-----------| Exception 异常：一般通过代码来处理。

--------------| 运行时异常:RuntimeException以及RuntimeException子类 都是属于运行时异常。如果一个方法内部抛出了一个运行时异常，那么方法上 可以声明也可以不 声明，调用者可以以处理也可以不处理。

--------------|编译时异常： 除了运行时异常就是编译异常。如果一个方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者也必须要处理。

 为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？

 运行时异常都是可以通过程序员良好的编程习惯去避免，所以java编译器就没有严格要求处理运行时异常。

Throwable类

Throwable是异常和错误的超类。

常用方法：

　　Throwabel常用的方法：
 　　toString() 返回当前异常对象的完整类名+病态信息。
 　　getMessage() 返回创建Throwable对象是传入的字符串信息。
　　 pintStackTrace() 打印异常的栈信息。

代码示例如下：

　

class Demo 
{
    public static void main(String[] args) 
    {
        //Throwable类测试
        Throwable t = new Throwable("Throwable异常测试");
        String info = t.toString();
        System.out.println("toString函数返回值："+info);
        String message = t.getMessage();
        System.out.println("message函数返回值："+message);
        t.printStackTrace();
    }
}

运行结果如下图：

 Throwable下分为异常和错误，那么如何根据异常信息来判断是错误还是异常呢？

　　如果程序出现不正常的信息，信息类名以Error结尾就是错误；以Exception结尾的就是异常。

Error：

　　一般是由于jvm或者硬件引发的问题，一般不会通过代码来处理。如下面代码：

　　　　//java虚拟机在默认的情况下只能管理64m内存。
  　　　　byte[] buf = new byte[1024*1024];

　　

异常

　　一般通过代码来处理。如：除数为0的算数异常。代码如下

　　int a = 0;

　　int b = 10/a;

　　此时jvm虚拟机就会抛出ArithmeticException异常。

Jvm当遇到异常代码时时如何工作的呢？

　　jvm运行到a/b这个语句的时候，发现b为0，除数为0在我们现实生活中是属于不正常的情况，jvm一旦发现了这种不正常的情况时候，那么jvm就会马上创建一个对应的异常对象，并且会调用这个异常对象 的printStackTrace的方法来处理。

在开发中不可能所有异常都由jvm来抛出和处理。程序人员必须在代码中进行相应的处理。

异常的处理方式：

　　1、捕获处理。

　　2、抛出处理。

下面来看一下捕获处理：

格式：

　　try{
    　　　　可能发生异常的代码；

   　　}catch(捕获的异常类型 变量名){
    　　　　处理异常的代码....
   　　}

 注意的细节：

　　1. 如果一个try块中出现了异常的代码，经过处理之后，那么try-catch块外面的代码可以正常执行。
  　 2. 如果一个try块中出现了异常的代码，那么在try块中出现异常的代码后面 的语句无法执行。
   　3. 一个try块后面可以跟多个catch块，也就是一个try块可以捕获多种异常的类型，但是捕获的异常类型必须从小到大进行捕获。

测试代码如下：

class Demo 
{
    public static void main(String[] args) 
    {
        int a = 10;
        int b = 2;
        int[] arr = null;
        div(a,b,arr);
        
    }

    //除数为0的异常代码测试
    public static void div(int a, int b,int[] arr){
        int c = 0;
        try{
            c = a/b; //此处发生异常后，try块中的以后语句不执行
            System.out.println("数组的长度："+ arr.length);
        }catch(ArithmeticException e){
            System.out.println("除数不能为0");
        }catch(NullPointerException e){
            System.out.println("出现了空指针异常....");
        }catch(Exception e){  
            System.out.println("捕获所有类型的异常");
        }
        System.out.println("捕获异常后，可以执行");
    }
}

抛出处理

抛出处理是通过 throw 和 throws两个关键字来实现。

throw 与throws两个关键字：
 1. throw关键字是用于方法内部的，throws是用于方法声声明上的。
 2. throw关键字是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。
 3. throw关键字后面只能有一个异常对象，throws后面一次可以声明抛出多种类型的 异常。

抛出处理要注意的细节：
   1. 如果一个方法内部抛出了一个编译时异常对象，那么该方法必须要声明抛出。
   2. 如果调用了一个声明抛出编译时异常的方法，那么调用者必须要处理。
   3. 如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）
   4. 在一种情况下只能抛出一种异常对象。

测试代码如下：

class Demo 
{
    public static void main(String[] args) 
    {
        int a = 10;
        int b = 0;
        int[] arr = {1,2};
        try{
            div(a,b,arr);
        }catch(Exception e){
            System.out.println("发生了异常："+e.getMessage());
        }
        
    }

    //除数为0的异常代码测试
    public static void div(int a, int b,int[] arr) throws ArithmeticException,NullPointerException{
        if(b==0){
            throw new ArithmeticException("除数不能为0");
        }else if(arr==null){
            throw new NullPointerException("数组指针为空");
        }
        int c = a/b;
        System.out.println("数组的长度是："+arr.length);
        System.out.println("捕获异常后，可以执行");
    }
}

何时使用抛出处理？何时捕获处理？原则是什么呢？

　　如果需要通知到调用者，代码出现了问题，此时就需要使用抛出处理。

　　如果代码时直接和用户打交道，遇到异常时就不要抛出，因为用户不会处理异常，此时就需要使用捕获处理了。

自定义异常类

sun提供了很多的异常类给我们用于描述程序中各种的不正常情况，但是sun 给我提供异常类还不足以描述我们现实生活中所有不正常情况，那么这时候我们就需要自定义异常类。

自定义异常类的格式：

　　自定义一个类继承Exception。

下面通过一个例子来理解，需求如下：模拟QQ登录时的情况，当有网络是正常登录，没有网络的时候抛出没有网络的异常信息。

代码如下：

//自定义没有网络的异常类
class NoNetWorkException extends Exception{
    public NoNetWorkException(String message){
        super(message);
    }
}

class Demo 
{
    public static void main(String[] args) 
    {
        String ip = "192.168.1.254";
        ip = null;
        try{
            loginQQ(ip);
        }catch(NoNetWorkException e){
            System.out.println("异常信息："+e.getMessage());
        }
    }

    public static void loginQQ(String ip)throws NoNetWorkException{
        if (ip==null)
        {
            throw new NoNetWorkException("网络连接失败");
        }
        System.out.println("登录成功");
    }

}

finally 块

finally块的使用前提是必须要存在try块才能使用。

finally块的代码在任何情况下都会执行的(比如return和throw关键字后)，除了jvm退出的情况。

finally非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都 会被释放。

使用代码示例如下：

//读取文件操作
import java.io.*;
class Demo 
{
    public static void main(String[] args) 
    {
        FileReader fileReader = null;
        try{
            //获取目标文件
            File file = new File("F:\test.txt");
            //建立数据通道
            fileReader = new FileReader(file);
            //读取文件
            char[] buffer = new char[1024];
            int lenght = 0;
            lenght = fileReader.read(buffer);
            System.out.println("读取到的内容："+new String(buffer,0,lenght));
        }catch(IOException e){
            System.out.println("读取文件失败");
        }finally{
            try{
                fileReader.close();
                System.out.println("释放资源文件成功");
            }catch(Exception e){
                System.out.println("释放资源文件失败");
            }
        }
    }
}

综上所述try块的使用方式有以下三种方式：

第一种： 比较适用于有异常要处理，但是没有资源要释放的。
   try{

   　　可能发生异常的代码
 
   }catch(捕获的异常类型 变量名){
    　　处理异常的代码
   }

第二种：比较适用于既有异常要处理又要释放资源的代码。
  
  try{

   　　可能发生异常的代码
 
   }catch(捕获的异常类型 变量名){
   　　 处理异常的代码
   }finally{ 
    　　释放资源的代码;
   }

第三种： 比较适用于内部抛出的是运行时异常，并且有资源要被释放。（运行时异常可以捕获也可以不捕获）
     try{

   　　可能发生异常的代码
 
   }finally{ 
   　　 释放资源的代码;
   }