java 异常详细介绍

最新推荐文章于 2022-08-03 00:25:42 发布

王胖子总叫我减肥

最新推荐文章于 2022-08-03 00:25:42 发布

阅读量189

点赞数 1

分类专栏： Java 文章标签： java exception

本文链接：https://blog.csdn.net/weixin_45519487/article/details/105652234

版权

Java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

1.异常

1.1概念：

异常:指程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在java面向对象的编程中，异常本身就是一个类，产生异常就是创建异常对象并抛出一个异常对象。java处理异常的方式是中断处理。

1.2 异常体系

异常机制其实就是帮助我们找到程序中的问题，异常的根类是java.util.Throowable,其下有两个子类：

java.lang.Error 和java.lang.Exception,平时我们说的异常就是指java.lang.Exception。

Throwable体系：

Error：属于比较严重的错误，无法处理饿错误，只能避免发生。

Exception：表示异常，异常在产生后，程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

Throwable中常用的方法：

public void printStackTrace(): 打印异常的详细信息。

信息中包含了异常的类型，异常的原因，异常出现的位置。

public String getMessage():获取发生异常的原因。

Public String toString():获取异常的类型和异常的描述信息。

1.3 异常的分类

我们平时所说的异常就是Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复。

异常（Exception）的分类：根据编译时期还是运行时期去检查异常。

编译时期异常：checked异常。在编译时期就会检查，如果没有处理异常，则编译失败。

运行时期异常：runtime异常。在运行时期，检查异常，在编译时期不会报错。

1.4 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类：

public class ArrayTools {
     // 对给定的数组通过给定的角标获取元素。
     public static int getElement(int[] arr, int index) {
     int element = arr[index];
     return element;
  }
}

测试类：

public class ExceptionDemo {
       public static void main(String[] args) {
             int[] arr = { 34, 12, 67 };
             intnum = ArrayTools.getElement(arr, 4)
             System.out.println("num=" + num);
              System.out.println("over");
       }
}

上述程序执行过程图解：

2.异常的处理

java异常处理的五个关键字：try、catch、finally、throw、throws

2.1 抛出异常

在java中，提供了一个Throw关键字，它用来抛出一个指定的异常对象。

步骤：

（1）创建一个异常对象。封装一些提示信息（信息可以自己编写）。

（2）需要将这个对象告知调用者，通过关键字throw完成。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名（参数）；

例：

throw new NullPointerException（“访问的Arr数组不存在”）；

throw new ArrayIndexOutBoundsException（“该索引在数组中不存在，已经超出范围”）；

public class Text {
    public static void main(String[] args) {
        int[] arr={1,2,3,4};
        int num=3;
        int getnum = getnum(arr, num);
        System.out.println(getnum);
    }

    private static int getnum(int[] arr, int num) {
        if(num<0||num>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
        }
        int number=arr[num];
        return number;
    }
}

如果产生了问题，我们会throw将问题描述类及异常抛出，就是将问题返回给该方法的调用者。但是调用者应该如何处理呢？一种是捕获处理，另外一种就是继续将问题声明出去，使用throws关键字声明处理。

2.2 Objects 的非空判断

在objects类主要的用途是操作对象的一些常用操作进行封装，比如HashCode方法，equals方法，都是一些静态方法，还有一种null-save（空指针安全的）或者null-tolerant(容忍空指针的)，

public static <T> T requireNonNull(T obj) :查看指定引用对象不是null。

查看源代码发现这里对null进行了抛出异常的处理；

public static <T> T requireNonNull(T obj) {
        if (obj == null)
              throw new NullPointerException()  ;
        return obj;
}

2.3 声明异常Throws

声明异常：就是问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，没有进行捕获异常，那么就必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上，用来表示当前方法不处理异常，而是提醒方法的调用者去处理异常（抛出异常）。

声明异常格式：

修饰符返回值类型方法名（参数） throws 异常类名1，异常类名2.....{ }

声明异常的代码演示：

public class ThrowsDemo {
      public static void main(String[] args) throws FileNotFoundException {
          read("a.txt");
        }
      // 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
      public static void read(String path) throws FileNotFoundException {
          if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
              // 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
                   throw new FileNotFoundException("文件不存在");
           }
      }
}

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {
        public static void main(String[] args) throws IOException {
               read("a.txt");
      }
     public static void read(String path)throws FileNotFoundException, IOException {
          if (!path.equals("a.txt")) {//如果不是 a.txt这个文件
         // 我假设 如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常 throw
            throw new FileNotFoundException("文件不存在");
             }
          if (!path.equals("b.txt")) {
                throw new IOException();
              }
      }
}

2.4 捕获异常 try ...catch

如果有异常出现的话，会立即终止程序，因此我们要处理异常：

（1）方法中不处理异常，就是声明抛出异常，有方法的调用者用throws关键字抛出异常来处理。

（2）在方法中使用try -catch 的语句块来处理异常。

try-catch的方式就是捕获异常。

捕获异常：java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常的语法：

try{
     编写可能出现异常的代码
    }catch（异常类型 e ）{
         处理异常的代码（记录日志/打印异常信息/继续抛出异常）
        }

try：该代码块中编写可以出现异常的代码。

catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注;try catch 要同时出现，不能单独使用

public class Text {
    public static void main(String[] args) {
        try {//异常产生，必须要处理，要么捕获，要么声明，上一节我们声明，现在捕获
            read("b.txt");
        }catch (FileNotFoundException e){
            //try 中抛出的是什么类型异常，在catch中就捕获什么类型异常
            System.out.println(e);
        }

    }

    private static void read(String path) throws FileNotFoundException {
        if(!path.equals("a,txt")){//如果不是a.txt文件就会抛出一个异常，
            //先不处理该异常，将它通过throws关键在方法声明出抛出
            throw new FileNotFoundException("文件不存在");
        }
    }
}

对于如何获取异常信息：

Throwable类中定义了一些查看异常的方法：

public String getMessage() :获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。

public void printStackTrace() :打印异常的跟踪栈信息并输出到控制台。包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

public String toString() :获取异常的类型和异常描述信息(不用)。

2.4 finally代码块

finally：有些异常的发生，会使程序进行跳转，导致有些代码无法执行，但是有一些特定的代码，不管异常是否发生，这些代码都一定要执行。finally就可以完美的解决这个问题，放在finally代码块中的代码一定会被执行。

finally的语法：

try ...catch...finally:（finally不能单独使用）。

public class Text {
    public static void main(String[] args) {
        try {//异常产生，必须要处理，要么捕获，要么声明，上一节我们声明，现在捕获
            read("b.txt");
        }catch (FileNotFoundException e){
            //try 中抛出的是什么类型异常，在catch中就捕获什么类型异常
            System.out.println(e);
        }finally {
            System.out.println("不管怎么样，这里的都会执行");
        }
        System.out.println("over");
    }

    private static void read(String path) throws FileNotFoundException {
        if(!path.equals("a,txt")){//如果不是a.txt文件就会抛出一个异常，
            //先不处理该异常，将它通过throws关键在方法声明出抛出
            throw new FileNotFoundException("文件不存在");
        }
    }
}

2.5 异常注意事项

多个异常使用捕获应该怎么操作？

（1）多个异常分别处理。

（2）多个异常一次捕获，多次处理。

（3）多个异常一次捕获一次处理。

一般我们使用一次捕获多次处理的方式，

try{
      编写可能会出现异常的代码
     }catch(异常类型A e){ 当try中出现A类型异常,就用该catch来捕获.
           处理异常的代码
           //记录日志/打印异常信息/继续抛出异常
     }catch(异常类型B e){ 当try中出现B类型异常,就用该catch来捕获.
          处理异常的代码
          //记录日志/打印异常信息/继续抛出异常
     }

注：使用这种异常处理方式，要求多个catch中的异常不能相同，并且要是catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理；

如果finally有return语句，就会永远的返回return的结果，要避免这种情况。

如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

父类没有抛出异常，子类重写父类方法，则就不能抛出异常，如果子类产生了异常就只能捕获，不能声明抛出。

3.自定义异常

3.1概述：

为什要自定义异常：我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN 没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等。

什么是自定义异常类：

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

异常类如何定义：

1. 自定义一个编译期异常: 自定义类并继承于java.lang.Exception 。

2. 自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException 。

3.2 练习：

我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

public class RegisterException extends Exception{
    /**
     * 空参构造
     */
    public RegisterException() {
    }
    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

import javax.security.auth.login.LoginException;

public class Text {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
    public static void main(String[] args) {
         //调用方法
        try{// 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(RegisterException e){
            //处理异常
            e.printStackTrace();
        } catch (LoginException e) {
            e.printStackTrace();
        }
    }
                //判断当前注册账号是否存在
               //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws LoginException, RegisterException {
           for (String name : names) {
             if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲"+name+"已经被注册了！");
             }
           }
           return true;
    }
}

王胖子总叫我减肥

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
java 异常详细介绍

1.异常 1.1概念：异常:指程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。在java面向对象的编程中，异常本身就是一个类，产生异常就是创建异常对象并抛出一个异常对象。java处理异常的方式是中断处理。 1.2 异常体系异常机制其实就是帮助我们找到程序中的问题，异常的根类是java.ut...
复制链接

扫一扫