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

最新推荐文章于 2022-09-06 21:04:13 发布

StrawberryBoy

最新推荐文章于 2022-09-06 21:04:13 发布

阅读量272

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/lhw19931201/article/details/106175757

版权

Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

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

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

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

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

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

Java中的异常体系：

图片来源于博客：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;
  }
}

例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;
  }
}

对于多异常的使用注意：

对方声明几个异常，就对应有几个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;
  }
}

例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);
  }
}

异常的其他细节

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

注意：

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;
  }
}

例：接下来说一下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;
  }
}

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

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

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

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表这可以被处理。

运行时异常(编译时不检测)

在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

StrawberryBoy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的异常机制-学习笔记

异常由来：异常问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。异常其实就是java对不正常情况进行描述后的对象体现。对于异常问题的划分：两种：一种是严重的问题，一种非严重的问题。对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。Java中的异常体系：图片来源于博客：https://www
复制链接

扫一扫

专栏目录