Java中的异常机制-学习笔记

曾经终败给现在 2023-03-14 10:44 21阅读 0赞

异常由来：异常问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。

异常其实就是java对不正常情况进行描述后的对象体现。

对于异常问题的划分：两种：一种是严重的问题，一种非严重的问题。

对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

Java中的异常体系：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70][]

图片来源于博客：[https://www.cnblogs.com/fwnboke/p/8529469.html][https_www.cnblogs.com_fwnboke_p_8529469.html]

在 Java中由于“万物皆对象” ，所以Java把异常也作为一种类，当做对象来处理。异常对象都是派生于 Throwable 类的一个实例 。 稍后还可以看到， 如果 Java 中内置的异常类不能够满足需求 ， 用户可以创建自己的异常类（自定义异常）。

需要注意的是， 所有的异常都是由 Throwable 继承而来 ， 但在下一层立即分解为两个分支 ： Error 和 Exception :

Error 类层次结构描述了 Java 运行时系统的内部错误和资源耗尽错误 。 应用程序不应该抛出这种类型的对象 。 如果出现了这样的内部错误 ， 除了通告给用户， 并尽力使程序安全地终止之外 ， 再也无能为力了。 这种情况很少出现 。  
在设计 Java 程序时 ， 需要关注 Exception 层次结构 。 这个层次结构又分解为两个分支 ：一个分支派生于 RuntimeException ; 另一个分支包含其他异常 。 划分两个分支的规则是 ： 由程序错误导致的异常属于 RuntimeException ; 而程序本身没有问题 ， 但由于像 I / O 错误这类问题导致的异常属于其他异常 。

派生于 RuntimeException 的异常包含下面几种情况 ：  
• 错误的类型转换 。  
• 数组访问越界  
•访问 null 指针  
不是派生于 RuntimeException 的异常包括 ：  
• 试图在文件尾部后面读取数据 。  
• 试图打开一个不存在的文件 。  
• 试图根据给定的字符串查找Class 对象 ， 而这个字符串表示的类并不存在 ,。

Java 语 言 规 范 将 派 生 于 Error 类 或 RuntimeException 类的所有异常称为非受查( unchecked ) 异常， 所有其他的异常称为受查 （ checked )异常。

Exception和Error的子类名都是以父类名作为后缀。

> Throwable中的方法：
> 
>  *  getMessage() 获取异常信息，返回字符串；
>  *  toString() 获取异常类名和异常信息，返回字符串；
>  *  printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void；
>  *  printStackTrace(PrintStream s) 通常用该方法将异常内容保存在日志文件中，以便查阅。

异常处理的5个关键字：**try、catch、throw、throws和finally。**

> throws和throw的区别**：**
> 
>  *  throws用于标识函数暴露出的异常（声明异常）；
>  *  throw用于抛出异常对象（抛出异常）；
>  *  thorws用在函数上（函数的头部末尾），后面跟异常类名而 throw用在函数内，后面跟异常对象。

try、catch和finally都不能单独使用，异常一共有三个格式：

第一个格式：

try
    {
        //执行程序代码，可能会出现异常
    }
    catch()
    {
        //捕获异常并处理
    }

第二个格式：

try
    {
        //执行程序代码，可能会出现异常
    }
    catch()
    {
        //捕获异常并处理
    }
    finally
    {
        一定会执行的代码;
    }

Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)；

无论是否有异常，finally块中的代码总是会被执行的。 finally语句在执行关闭资源的语句时非常有用 。

第三种格式：

try
    {
        //执行程序代码，可能会出现异常
    }
    
    finally
    {
        一定会执行的代码;
    }

try-finally可用在不需要捕获异常的代码，可以保证资源在使用后被关闭。例如IO流中执行完相应操作后，关闭相应资源；使用Lock对象保证线程同步，通过finally可以保证锁会被释放；数据库连接代码时，关闭连接操作等等。

例1：一个简单的异常程序。

public class HelloWorld {
    
      public static void main(String[] args) {
        MyDemo m=new MyDemo();
        try
        {
          int x=m.div(3,0);
          System.out.println("x="+x);
        }
        catch(Exception e)  //Exception e = new ArithmeticException();
        {
          System.out.println(e.getMessage()); //     / by zero;
          System.out.println(e.toString());      // 异常名称 ： 异常信息
          e.printStackTrace();
          //异常名称，异常信息，异常出现的位置。
          //其实jvm默认的异常处理机制，就是在调用printStackTrace方法,打印异常的堆栈的跟踪信息
        }
        System.out.println("over");
      }
    }
    class MyDemo
    {
      int div(int a,int b) throws Exception 
    //在方法上通过throws的关键字声明了该方法有可能会出现问题
      {
        return a/b;
      }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1][]

例2： 多异常情况下的例子

public class HelloWorld {
    
      public static void main(String[] args) {
        MyDemo m=new MyDemo();
        try
        {
          int x=m.div(5,1);
          System.out.println("x="+x);
        }
        catch(ArithmeticException a)
        {
          System.out.println(a.toString());     // 异常名称：异常信息
          System.out.println("被0除了!");
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
          System.out.println(e.toString());
          System.out.println("数组下标越界啦！");
        }
        System.out.println("over");
      }
    }
    class MyDemo
    {
    //声明异常时，建议声明更为具体的异常。这样处理的可以更具体
    //声明多个异常时，之间用逗号隔开
      int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
      {
        int[] arr=new int[a];
        System.out.println(arr[5]);  //如果数组下标越界，不会执行下面的return语句，因为发生了异常
        return a/b;
      }
    }

![20200517171843242.png][]

>  对于多异常的使用注意：
> 
> 1.  对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。这是因为父类异常囊括了子类异常，如果父类异常在前，子类异常永远捕获不到，导致有时候无法准确描述错误信息。

# 自定义异常 #

如何自定义异常呢？

> 自定义异常就是自定义类继承Exception或者其子类。
> 
> 因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题进行自定义的异常封装。
> 
> 当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。
> 
> 通过构造函数定义异常信息。
> 
>     //自定义异常
>     Class DemoException extends Exception
>     {
>     DemoException(String message)
>     {
>     //因为父类中已经把异常信息的操作都完成了。
>     //所以子类只要在构造时，将异常信息通过super语句传递给父类即可
>     super(message);
>     }
>     }
> 
> 通过throw将自定义异常抛出。

//自定义异常
    public class HelloWorld {
    
      public static void main(String[] args) {
        MyDemo m=new MyDemo();
        try
        {
          int x=m.div(3,-1);
          System.out.println("x="+x);
        }
        catch(FuShuException f)
        {
          System.out.println(f.toString());
          System.out.println("错误的负数是："+f.getValue());
        }
        System.out.println("over");
      }
    }
    
    class FuShuException extends Exception
    {
      private int value;
      FuShuException()
      {
        super();
      }
      FuShuException(String msg,int value)
      {
        super(msg);
        this.value = value;
      }
    
      public int getValue()
      {
        return value;
      }
    }
    
    class MyDemo
    {
      int div(int a,int b) throws FuShuException
      {
        if(b<0)
          throw new FuShuException("分母出现了是负数的情况--/ by fushu",b);
        return a/b;
      }
    }

![20200517174723518.png][]

例1：建立一个图形接口，声明一个面积函数。圆形和矩形都实现这个接口，并得出两个图形的面积。  
注：体现面向对象的特征，对数值进行判断。用异常处理。不合法的数值要出现“这个数值是非法的”提示，不再进行运算。

//自定义异常，当出现不合法数值时程序终止可知该异常继承自RuntimeException
    class ValueErrorException extends RuntimeException
    {
      ValueErrorException(String str)
      {
        super(str);
      }
    }
    interface Shape
    {
      double Area();
    }
    //矩形实现接口
    class Rec implements Shape
    {
      private double length,width;
      Rec(double l,double w)  //此时为运行时异常，所以无需在此处声明异常
      {
        if(l<0 ||w<0)
          throw new ValueErrorException("出现非法值");
        this.length=l;
        this.width=w;
      }
      public double Area()
      {
        return length*width;
      }
    }
    //圆实现接口
    
    class Circle implements Shape
    {
      private double radius;
      public static final double PI=3.1415;
      Circle(double r) {
        if (r < 0)
          throw new ValueErrorException("半径出现了负值！");
        this.radius = r;
      }
        public double Area()
        {
          return PI*radius*radius;
        }
    }
    
    public class HelloWorld {
      public static void main(String[] args) {
        Rec r=new Rec(-8,3);
        double a=r.Area();
        System.out.println(a);
        Circle c=new Circle(3);
        double a1=c.Area();
        System.out.println(a1);
      }
    }

![20200518110735185.png][]

异常的其他细节

> 1.  RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明 ；
> 2.  一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类；
> 3.  如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。

注意：

Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常 。

如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过。

之所以不用在函数后声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

//自定义异常继承自RuntimeException运行时异常
    public class HelloWorld {
    
      public static void main(String[] args) {
        MyDemo m=new MyDemo();
        //因为抛出的是运行时异常，可以选择捕获或者不捕获
        int x=m.div(3,-1);
        System.out.println("x="+x);
    
        System.out.println("over");
      }
    }
    
    class FuShuException extends RuntimeException
    {
      FuShuException(String msg)
      {
        super(msg);
      }
    }
    
    class MyDemo
    {
    //如果在函数内抛出该异常，函数上可以不用声明，编译一样通过
      int div(int a,int b) //自定义异常继承自RuntimeException，此处可以不声明
      {
        if(b<0)
          throw new FuShuException("分母出现了是负数的情况--/ by fushu");
        if(b==0)
          throw new ArithmeticException("分母为0啦！");
    
        return a/b;
      }
    }

![20200517180121744.png][]

例：接下来说一下finally代码块：定义一定执行的代码。

public class HelloWorld {
    
      public static void main(String[] args) {
        MyDemo m=new MyDemo();
        try
        {
          int x=m.div(3,-1);
          System.out.println("x="+x);
        }
        catch(FuShuException f)
        {
          System.out.println(f.toString());
        }
        finally
        {
          System.out.println("一定会执行的语句");
        }
        System.out.println("over");
      }
    }
    
    class FuShuException extends RuntimeException
    {
      FuShuException(String msg)
      {
        super(msg);
      }
    }
    
    class MyDemo
    {
      int div(int a,int b) throws FuShuException
      {
        if(b<0)
          throw new FuShuException("分母出现了是负数的情况--/ by fushu");
        return a/b;
      }
    }

![202005171808112.png][]

注意：finally语句在执行关闭资源的语句时非常有用，例如关闭数据库的操作。

最后再总结一下异常的知识点：

> 1.  当函数内有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。 
> 2.  如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。
> 3.  finally中定义的通常是关闭资源代码。因为资源必须释放。finally只有一种情况不会执行。当执行到系统退出System.exit(0);fianlly不会执行。
> 4.  当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常异常信息传递给父类的构造函数。                     
>     
>         class MyException extends Exception
>         {
>             MyException(String message)
>         	{
>         		super(message);
>         	}
>         }
>     
>      
> 5.  异常的好处：将问题进行封装。将正常流程代码和问题处理代码相分离，方便于阅读。
> 6.  多个catch，父类的catch放到最下面。
> 7.  在子父类覆盖时：子类抛出的异常必须是父类的异常的子类或者子集；如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
> 8.  当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。                                                                                     
>     
>         try
>         {
>             throw new AException();
>         }
>         catch (AException e)
>         {
>             throw e;
>         }
>     
>      
> 9.  如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
>     
>      
>     
>         try
>         {
>             throw new AException();
>         }
>         catch (AException e)
>         {
>             // 对AException处理。
>             throw new BException();
>         }
>     
>      
> 10. 异常有两种：
> 
>  *  编译时被检测异常：
> 
> 该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表这可以被处理。
> 
>  *  运行时异常(编译时不检测)
> 
> 在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
> 
>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70]: /images/20230312/65d09a43226b4fef99a3a744901028c0.png
[https_www.cnblogs.com_fwnboke_p_8529469.html]: https://www.cnblogs.com/fwnboke/p/8529469.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xodzE5OTMxMjAx_size_16_color_FFFFFF_t_70 1]: /images/20230312/543f7ce77b4142fe942b47200b002789.png
[20200517171843242.png]: /images/20230312/9f117d2146b348739f2387be09ae1b85.png
[20200517174723518.png]: /images/20230312/335b9f941fb2459999699b28c4f693d3.png
[20200518110735185.png]: /images/20230312/199fb6427db6494586e2153b5db7d652.png
[20200517180121744.png]: /images/20230312/31c037116fb44de4aa6d1b24d71dc163.png
[202005171808112.png]: /images/20230312/3227273807b0401a85a5151fd6cf306c.png