java异常

发布时间:2023年12月17日

目录

1.异常

1.1异常的概述

1.2异常的体系

1.3 在jvm中默认处理异常的机制

2. 处理异常的方式

2.1有两大类处理异常的方式:

2.2 异常捕获的第一种格式

2.3 异常捕获的第一种格式的多种异常情况

2.4 异常捕获的第二种格式

2.5 异常处理的第三种格式

3. 继承体系中的常用方法

4.自定义异常

4.1 throw关键字

4.2 throws关键字

4.3 throw和throws的比较

4.4 自定义异常类


1.异常

1.1异常的概述

  • 在java程序《运行》过程中,出现的不正常情况,出现的错误,称为异常

  • 异常就是一个对象,描述那些不符合生活正常情况的异常情况,包含了这些情况的原因、类型、描述以及位置,这些内容都封装到异常对象中。

  • 异常也是一种处理异常情况的机制,可以进行跳转、捕获以及结束程序,提供了程序退出的安全通道

  • image-20230212220608181

1.2异常的体系

  • Throwable:可抛出的,是异常体系的顶层父类,其它的异常或者错误都是Throwable的子类类型,只有Throwable的体系类型,才可以使用异常的处理机制

  • Error:错误,是Throwable的子类,用于描述那些无法捕获和处理的错误情况,属于非常严重的错误,StackOverflowError

  • Exception:异常,是Throwable的子类,用于描述那些可以捕获和处理的例外情况,属于不太严重的错误ArrayIndexOutOfBoundsException,NullPointerException

  • RuntimeException:运行时异常,是Exception的特殊的子类,在编译阶段不做检查的一个异常

    这种异常我们不需要处理,由虚拟机掌管,比如NullPointerException,ArrayIndexOutOfBoundsException

  • 体系图:

    image-20230212222526711

1.3 在jvm中默认处理异常的机制

  • 演示代码:

/**
 * 在jvm中 默认处理异常的机制
 */
public class Simple01 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test1();
 ?  }
?
 ? ?public static void test1() {
 ? ? ? ?test2();
 ?  }
?
 ? ?public static void test2() {
 ? ? ? ?test3();
 ?  }
?
 ? ?public static void test3() {
 ? ? ? ?int i = 1 / 0;
 ? ? ? ?System.out.println(i);
 ?  }
}
  • 在代码的某个位置,出现了和正常情况不同的情况,就将异常情况封装到一个异常对象中。

  • 将异常对象抛给调用该方法的方法,A调用B, B有问题就把异常抛给A。

  • 某个方法接收到底层方法抛上来的异常,也没有办法自己处理,继续向上抛出,最终抛给main方法,main方法也没有办法处理,抛给调用自己的jvm虚拟机

  • Jvm虚拟机是我们手动调用的,只能将异常对象的所有信息,通过错误信息打印出来,结束jvm虚拟机

  • 总结,jvm默认处理的方式:【一层一层向上抛,jvm接收到之后结束自己】

2. 处理异常的方式

2.1有两大类处理异常的方式:

  • 异常的声明:某个方法有编译时异常,编译就会无法通过,需要在异常所在的方法声明上,声明该方法可能出现的编译时异常

    public ?static void ?test () throws FileNotFoundException 
    {
    FileInputStream fileInputStream = new FileInputStream("/Users/lihongyan/Desktop/未命名.html");
     }
    ?
    JDK11新增方式
    Path path = Paths.get("/Users/lihongyan/Desktop/未命名.html");
    String data = Files.readString(path);
    System.out.println(data);
  • 异常的捕获:出现异常之后,可以通过某些格式来捕获,可以让程序在出现异常之后,继续运行,可以定义自己处理异常的逻辑。

  • 捕获处理异常的代码格式:

    • try...catch

    • try...catch...finally

    • try...finally(无法捕获处理异常)

2.2 异常捕获的第一种格式

  • 格式

    • try ? {
       ? ? ?   可能发生异常的代码
       ? ?  } catch(可能出现异常的类型 标识符) {
                      这种异常出现之后的处理方式
       ? ?  }
  • try:试一试

    • try语句块中,是可能会运行失败的代码,try语句是用于对异常进行检测

  • catch:抓住、捕获

    • 抓住try语句中出现的异常,并且定义异常处理的方式

  • 运行机制:

    • 运行try语句中的代码

    • 如果没有发生任何异常,那么不再运行catch块中的内容

    • 如果发生了catch中声明的异常,那么就会被捕获到这个异常,执行catch块中的内容(try中如果发生了异常,try中,该语句后面的代码都无法执行了,直接跳到catch中)

    • 如果发生了catch中没有声明的异常,那么就无法捕获该异常,该异常的处理就使用jvm的默认处理方式

2.3 异常捕获的第一种格式的多种异常情况

  • 在一段代码中,可能出现多种异常(虽然一次运行只能出现一个异常,但是出现哪个异常我们是不清楚的),所以要准备多种异常情况的处理机制。

  • 格式:

  • try {
            可能出现异常的代码
    } catch (异常类型1 ?异常对象名1) {
        异常类型1出现之后的处理办法
    } catch (异常类型2 ?异常对象名2) {
        异常类型2出现之后的处理办法
    }
    ....
    } catch (异常类型n 异常对象名n) {
        异常类型n出现之后的处理办法
    }
  • 执行流程:

    • 执行try中的内容,如果没有异常,try...catch语句直接结束

    • 如果有异常,那么就在发生异常的代码位置直接跳转到catch块中,try中后面的代码就不再继续运行了

    • 继续匹配各个catch块中的异常类型,从上到下,一旦匹配到某个catch声明的异常类型,就直接执行该catch块的处理方式。处理完成之后,try...catch语句就直接结束了,不会再去匹配后面其他的catch块的异常类型

  • 代码示例:

/**
 * 异常捕获的第一种格式的多种异常情况
 */
public class Simple02 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
?
 ? ?public static void test() {
 ? ? ? ?Scanner sc = new Scanner(System.in);
 ? ? ? ?System.out.println("请录入一个除数");
 ? ? ? ?try {
 ? ? ? ? ? ?int i = 100 / sc.nextInt();
 ? ? ? ? ? ?System.out.println(i);
 ? ? ? ? ? ?int[] arr = {1, 3, 5, 7, 9};
 ? ? ? ? ? ?System.out.println(arr[5]);
 ? ? ?  }
 ? ? ? ? ?catch (ArithmeticException a) {
 ? ? ? ? ? System.out.println("出现数学运算异常");
 ? ? ?  } catch ( ArrayIndexOutOfBoundsException a) {
 ? ? ? ? ? System.out.println("出现索引越界异常");
 ? ? ?  }
 ? ? ? ?// catch (ArithmeticException  | ArrayIndexOutOfBoundsException a) {
 ? ? ? ?// ? ? System.out.println(a.getMessage());
 ? ? ? ?// }
 ?  }
}
?
  • 注意事项:

    • 如果在各个catch块中,出现了子父类的异常类型,那么子类异常的catch块,必须在父类异常catch块的上面,因为从上到下匹配方式,如果父类的catch块在上面,下面的catch块就没有出现的意义了。

    • 在jdk1.7之后,可以对异常类型进行逻辑的或运算,使用|表示,多种异常类型,可以使用相同的处理方式:

  • catch(异常类型1 | 异常类型2 ?异常对象名称) {
                异常类型1和2的共同处理方式a.getMessage()
    }

2.4 异常捕获的第二种格式

  • 格式:

  • try {
            可能发生异常的代码
          } 
     ?catch (可能发生的异常类型 ?异常对象名称) {
             当前异常类型的处理方式
    } ?finally {
         ? 一定要执行的代码
    }
  • finally:一定要执行的代码

    • 如果把某句代码放在try中,可能在这句话前面有异常,那么这句话就无法执行;如果把某句代码放在catch中,有可能try中没有异常,就无法执行这句话;如果把某句代码放在try...catch之后,可能有未捕获的异常,那么这句代码也无法执行。

    • finally:也是一个代码块,在这个代码块中的代码,一定会执行,无论上面描述的哪种情况,都会执行。

    • 作用:一般使用关闭资源

    • -示例代码:

/**
 * 异常捕获的第二种格式
 */
public class Simple03 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
?
 ? ?public static void test() {
 ? ? ? ?Scanner sc = new Scanner(System.in);
 ? ? ? ?System.out.println("请录入一个除数");
 ? ? ? ?try {
 ? ? ? ? ? ?int i = 100 / sc.nextInt();
 ? ? ? ? ? ?System.out.println(i);
 ? ? ? ? ? ?int[] arr = {1, 3, 5, 7, 9};
 ? ? ? ? ? ?System.out.println(arr[5]);
 ? ? ?  }
 ? ? ? ? catch (ArithmeticException ?| ArrayIndexOutOfBoundsException a) {
 ? ? ? ? ? ? System.out.println(a.getMessage());
 ? ? ? ? } finally {
 ? ? ? ? ? ?System.out.println("我一定要执行");
 ? ? ?  }
 ?  }
}

2.5 异常处理的第三种格式

  • 格式:

  • try {
            可能发生异常的代码
    } finally {
        一定要执行的代码
    }
  • 作用:

    • 第三种格式无法捕获和处理异常,一旦发生任何异常,仍然会按照默认的处理方式,一层一层向上抛出,到达jvm,结束虚拟机

    • 无论try中的语句是否发生异常,finally中的代码都一定有执行的机会

    • 如果有两句代码,都需要有执行的机会,不希望第一句的成功与否影响到第二句的执行机会,那么就把这两句代码分别放在try和finally中,就是try中你报你的错,我finally中代码该咋执行咋执行。

  • 代码示例:

import java.util.Scanner;
?
/**
 * 异常处理的第三种格式
 */
public class Simple04 {
 ? ?public static void main(String[] args) {
 ? ? ? ?try {
 ? ? ? ? ? ?System.out.println("输入一个除数");
 ? ? ? ? ? ?System.out.println(1 / new Scanner(System.in).nextInt());
 ? ? ?  } finally {
 ? ? ? ? ? ?System.out.println("一定有机会执行的代码");
 ? ? ?  }
 ?  }
}

3. 继承体系中的常用方法

  • 在异常的继承体系中,所有的方法定义在了Throwable这个顶层父类中,子类中几乎没有什么特有方法

  • Throwable中的构造方法: Throwable():创建一个没有任何参数的异常对象 Throwable(String message):创建一个带有指定消息的异常对象 Throwable(Throwable cause):创建一个有原因异常的异常对象

  • 常用成员方法: getMessage():获取异常的详细信息 toString():获取异常对象的详细信息 printStackTrace():打印异常的调用栈轨迹(有关异常的方法调用路径)

  • 代码示例:

import java.util.Scanner;
?
/**
 * 继承体系中的常用方法
 */
public class Simple05 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?try {
 ? ? ? ? ? ?System.out.println("输入一个除数");
 ? ? ? ? ? ?System.out.println(1 / new Scanner(System.in).nextInt());
 ? ? ?  } catch (ArithmeticException ae) { ? // 这里可以介绍一下exception异常
 ? ? ? ? ? ?System.out.println(ae.getMessage());//获取当前异常对象的消息字符串
 ? ? ? ? ? ?System.out.println(ae.toString());//获取当前异常对象的字符串描述
 ? ? ? ? ? ?System.out.println("--------------------------");
 ? ? ? ? ? ?ae.printStackTrace();//获取当前异常对象的方法调用路径
 ? ? ?  }
 ?  }
}

4.自定义异常

4.1 throw关键字

  • throw:抛出,用于抛出一个异常对象

  • 异常是一个对象,当程序运行到某种情况时,程序员认为这种情况和现实生活不符合,就把当前的对于情况的描述,封装到一个异常对象中,通过throw关键字将异常对象进行抛出。

  • 作用: 创建一个异常对象,使用throw关键字抛出,实现了程序的结束或者跳转

  • 说明:

  • 如果抛出的是运行时异常,在编译阶段就相当于没有异常,可以不处理这个异常
    如果抛出的是编译时异常,那么这个异常必须使用异常处理的方式处理,才能编译成功
  • 代码示例

public class Simple06 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?Person person = new Person();
 ? ? ? ?person.setName("小明");
 ? ? ? ?try {
 ? ? ? ? ? ?person.setAge(-20);
 ? ? ?  }catch ( RuntimeException re) {
 ? ? ? ? ? ?System.out.println(re.getMessage());
 ? ? ?  }
 ? ? ? ?System.out.println(person);
 ?  }
}
?
public class Person {
 ? ?private ?String name;
 ? ?private Integer age;
?
 ? ?public Person(String name, Integer age) {
 ? ? ? ?this.name = name;
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?public String getName() {
 ? ? ? ?return name;
 ?  }
?
 ? ?public Person() {
 ?  }
?
 ? ?public void setName(String name) {
 ? ? ? ?this.name = name;
 ?  }
?
 ? ?public Integer getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?public void setAge(Integer age) {
 ? ? ? ?if (age <= 0) {
 ? ? ? ? ? ?// 年龄小于0,这种情况不符合生活正常情况,就将这种情况封装成异常对象
 ? ? ? ? ? ?// 如果抛出的是运行时异常,在编译阶段就相当于没有异常,可以不处理这个异常
 ? ? ? ? ? ?// RuntimeException re = new RuntimeException();
 ? ? ? ? ? ?// throw re;//将异常对象
 ? ? ? ? ? throw new RuntimeException("年龄不能为负值");
?
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
 ? ?@Override
 ? ?public String toString() {
 ? ? ? ?return "Person{" +
 ? ? ? ? ? ? ? ?"name='" + name + '\'' +
 ? ? ? ? ? ? ? ?", age=" + age +
 ? ? ? ? ? ? ? ?'}';
 ?  }
}
 

4.2 throws关键字

  • throws:抛出,用于声明一个异常类型

  • 在某个方法中,有一些编译时异常,没有给出处理的方案,没有捕获这个异常,没有处理这个异常,就说明这个方法是一个有问题的方法。为了让调用者在调用时,可以考虑到处理这个异常,所必须在当前方法的声明上,声明这个异常。

  • 声明格式:

    修饰符 返回值类型 方法名称(参数列表) throws 异常类型1, 异常类型2,... {
     ?      可能出现异常的代码
    }

  • 注意事项:

    • 如果抛出的是一个运行时异常,那么就相当于没有抛出异常,这种异常也不需要在方法上声明;声明了一个运行时异常,也相当于没有做任何声明

    • 如果抛出的是一个编译时异常,那么就必须进行声明或者捕获;如果声明了一个编译时异常,将来调用这个方法时,也相当于有一个声明的异常。

    • 在声明异常的时候,尽量声明<小>的异常、尽量声明<少>的异常

    • 一个方法暴露太多异常,别人不敢调用你了

    • 代码示例:

?
public class Simple07 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?Person person = new Person();
 ? ? ? ?person.setName("小明");
 ? ? ? ?try {
 ? ? ? ? ? ?person.setAge(-20);
 ? ? ?  }catch ( Exception re) {
 ? ? ? ? ? ?System.out.println(re.getMessage());
 ? ? ?  }
 ? ? ? ?System.out.println(person);
 ?  }
}
?
public class Person {
 ? ?private ?String name;
 ? ?private Integer age;
?
 ? ?public Person(String name, Integer age) {
 ? ? ? ?this.name = name;
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?public String getName() {
 ? ? ? ?return name;
 ?  }
?
 ? ?public Person() {
 ?  }
?
 ? ?public void setName(String name) {
 ? ? ? ?this.name = name;
 ?  }
?
 ? ?public Integer getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?public void setAge(Integer age) throws Exception {
 ? ? ? ?if (age <= 0) {
 ? ? ? ? ? ?// 年龄小于0,这种情况不符合生活正常情况,就将这种情况封装成异常对象
 ? ? ? ? ? ?// 创建编译时 异常
 ? ? ? ? ? throw new Exception("年龄不能为负值");
?
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?@Override
 ? ?public String toString() {
 ? ? ? ?return "Person{" +
 ? ? ? ? ? ? ? ?"name='" + name + '\'' +
 ? ? ? ? ? ? ? ?", age=" + age +
 ? ? ? ? ? ? ? ?'}';
 ?  }
}
?

4.3 throw和throws的比较

  • throw是对异常对象的抛出,throws是对异常类型的声明

  • throw是对异常对象实实在在的抛出,一旦使用了throw关键字,就一定有一个异常对象出现;

    throws是对可能出现的异常类型的声明,即使声明了异常类型,在该方法中,也可能不出现任何异常。

  • throw后面只能跟一个异常对象;

    throws可以跟很多个异常类型

4.4 自定义异常类

public class Simple08 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test1();
 ? ? ? ?test2();
 ? ?try {
 ? ? ? ? test3();
 ? ? } catch (ExceptionDemo2 e) {
 ? ? ? ? System.out.println(e.getMessage());
 ? ? }
 ?  }
 ? ?private static void test1() ?throws ?ExceptionDemo1 {
 ? ? ? ?String str = null;
 ? ? ? ?System.out.println(str.length());
 ?  }
 ? ?private static void test2() ?throws ExceptionDemo2 {
 ? ? ? ?String str = null;
 ? ? ? ?System.out.println(str.length());
 ?  }
 ? ?private static void test3() {
 ? ? ? ?throw new ExceptionDemo2("异常");
 ?  }
}
?
class ExceptionDemo1 extends ?RuntimeException {
?
}
class ExceptionDemo2 extends ?Exception {
 ? ?public ExceptionDemo2(String message) {
 ? ? ? ?super(message);
 ?  }
?
 ? ?public ExceptionDemo2() {
 ?  }
}

文章来源:https://blog.csdn.net/2301_77351901/article/details/135049326
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。