javaSE (七)：异常

404_NOT_FOUND@

已于 2024-04-24 16:30:19 修改

阅读量779

点赞数 36

分类专栏： JavaSE 文章标签： java

于 2024-04-24 15:21:19 首次发布

本文链接：https://blog.csdn.net/m0_70830675/article/details/138157484

版权

JavaSE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的异常处理机制，包括异常的概念、抛出机制、常见异常类型（如Error和运行时异常）、异常处理的关键字（try、catch、finally、throw、throws）以及编译期和运行期异常的区别，最后讲解了自定义异常的创建和使用。

摘要由CSDN通过智能技术生成

1.编译时期异常（即checked异常、受检异常）

2.运行时期异常（即runtime异常、unchecked异常、非受检异常）

一、Java 异常概述

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的

比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等

1.异常概念

指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致 JVM的非正常停止

!!!注意

异常指的并不是语法错误。

语法错了，编译不通过，不会产生字节码文件，根本不能运行。

2.异常的抛出机制

Java中是如何表示不同的异常情况，又是如何让程序员得知，并处理异常的呢？

Java中把不同的异常用不同的类表示

①一旦发生某种异常，就创建该异常类型的对象，并且抛出。然后程序员可以捕获到这个异常对象，并处理

②如果没有捕获这个异常对象，那么这个异常将会导致程序终止

3.如何对待异常

对于程序出现的异常，一般有两种解决方法：

①是遇到错误就终止程序的运行。

②是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的检测、以及异常的处理，保证代码的健壮性。

二、 java异常体系结构

1.Throwable

java.lang.Throwable类是Java程序执行过程中发生的异常事件对应的类的根父类。

Throwable中的常用方法：

①public void printStackTrace()：打印异常的详细信息。包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用printStackTrace。

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

2. Throwable分类

Throwable可分为两类：Error和Exception

分别对应着 java.lang.Error java.lang.Exception 两个类

①Error：

Java虚拟机无法解决的严重问题

比如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

例如：StackOverflowError（栈内存溢出）和 OutOfMemoryError（堆内存溢出，简称OOM）。

②Exception:

其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。

三、常见的异常

1.Error

堆溢出: OutOfMemoryError

栈溢出: StackOverflowError

2.异常--运行时异常

数组越界异常

类型转换异常

数字格式化异常

空指针异常

算术异常

public class Demo1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        if(b!=0){
            System.out.println(a/b);//ArithmeticException  算术异常
        }

        int[] c = new int[2];
        c[3] = 0;                  //ArrayIndexOutOfBoundsException 数组索引越界

        String s = "abc";
        s.charAt(4);               //StringIndexOutOfBoundsException 字符串索引越界

        Object s = new Integer(10);
        String s1 = (String)s;    //ClassCastException 类型转换异常

       Integer.parseInt("abc");//NumberFormatException

        String s = null;
        s.length();              //NullPointerException使用null中的方法属性，一般在java中也称为空指针异常
        System.out.println("aaaaaaaaaaaaa");
    }
}

四、异常处理

●Java编程语言使用异常处理机制为程序提供了错误处理的能力

● Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

• 基本语法

try{

可能会发生异常的代码

}catch(异常类型引用名){

异常处理代码

}

finally{

必须执行代码

}

1.try

检测不安全的代码块（发现异常）

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

2.catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去 catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

捕获异常的有关信息：

与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

• getMessage() 获取异常信息，返回字符串

• printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

public class Demo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try{
            int c = a/b;//算术运算
        }catch(ArithmeticException ae){
            ae.printStackTrace();//打印异常信息到控制台，一般在开发调试阶段使用
            System.out.println("算术异常");
        }
        System.out.println("aaaaaaaaaaaaaaa");
    }
}

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

public class Demo3 {
    public static void main(String[] args) {

        try{
            String s = null;
            s.length();

            int num = Integer.parseInt("10ab");

            int[] a = new int[5];
            for (int i = 0; i < a.length; i++) {
                System.out.println(a[i]);
            }
        }catch(ArrayIndexOutOfBoundsException ai){
            ai.printStackTrace();
            System.out.println("数组索引越界，越界索引:"+ai.getMessage());//拿到索引异常原因
        }catch(NumberFormatException nfe){
            nfe.printStackTrace();
            System.out.println("数组格式化异常:"+nfe.getMessage());
        }catch(Exception e){ //在后面catch Exception类型，可以捕获任意的异常类型，但是必须要放在后面
            e.printStackTrace();
            System.out.println("系统忙 请稍后再试");
        }
        System.out.println("aaaaaaaaaaaaaaa");
    }
}

3.finally

finally该内容总是会执行的，只能有一个finally语句

finally{

必须执行的逻辑

}

场景一：异常没有捕获到，后面的代码无法执行，但是finally中的代码是可以执行的

public class Demo4 {
    public static void main(String[] args) {
        try{
           int num = Integer.parseInt("10ac");
        }catch(ArrayIndexOutOfBoundsException ao){//异常类型写错
            ao.printStackTrace();
        }finally{
            System.out.println("aaaaaaaaaaaaa");
        }
        System.out.println("bbbbbbbbbbbbb");
    }
}

场景二：确保在出现异常的情况下，依然最终把流对象关闭掉

public class Demo5 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = null;
        try{
            in = new FileInputStream("D:/demo.txt");//文件一旦找不到就会出现异常
            while(in.read()!=-1){

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件找不到异常");
        }finally {
            if(in!=null){
                in.close();
            }
        }
        System.out.println("aaaaaaaaaaaaaaa");
    }
}

场景三：无论是try中还是catch进行return，也必须在return之前，先执行finally代码块

public class Demo6 {
    public static void main(String[] args) {
        test(10,5);
        System.out.println("aaaaaaaaaaa");

    }

    public static int test(int a,int b){
        try {
            int c= a/b;
            return c;
        } catch (ArithmeticException ae) {
            ae.printStackTrace();
            System.out.println("算术异常");
            return -1;
        }finally {
            System.out.println("关闭流");
        }
    }
}

4.throws

定义一个方法的时候可以使用throws关键字声明,表示此方法不处理异常，而交给方法调用处进行处理

例如: public void test throws 异常1，异常2，异常3{

}

● 任何方法都可以使用throws关键字声明异常类型，包括抽象方法

● 调用使用了throws的方法时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明

● 如果抛出的是运行期异常,则不会有任何提示,需要查看所调用的方法结构

Demo7 {
    public static void main(String[] args) {
        try {
            //最顶层的main方法中就不能再抛出了，必须对异常进行处理
            methodA();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            System.out.println("编码异常");
        }
        System.out.println("main");
    }
    public static void methodA() throws UnsupportedEncodingException {
        methodB();
        System.out.println("methodA");
    }

        /*
         用methodB方法模拟一个底层方法
         throws 异常类型 声明此方法中可能会出现给定的异常，并且该方法不处理
         谁调用谁处理
        */

    public static void methodB() throws UnsupportedEncodingException {
        String s = "abc";
        s.getBytes("gbk-1");//根据一个编码表进行转换,throws UnsupportedEncodingException表示此方法可能会出现UnsupportedEncodingException异常
        System.out.println("methodB");
    }

5.throw

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象

语法：throw new 异常类构造方法

如： throw new RunTimeException();

public static void someMethod() {

if (1==1) {

throw new RuntimeException("错误原因");

}

}

public class Demo9 {

    public static void main(String[] args) {
      try {
          char c = level(101);
      }catch(ArithmeticException a){
          a.printStackTrace();
          System.out.println(a.getMessage());
      }
        System.out.println("aaaaaaaaaaaa");
    }

    public static char level(int score) throws ArithmeticException{
        if (score<0||score>100){
            throw new ArithmeticException("非法的分数");//当不满足某种条件时，程序中主动的抛出异常对象，终止此方法继续向下执行，通过异常构造方法传入异常原因
        }
        if (score>=90&&score<=100) {
            return 'A';
        }else {
            return 'B';
        }
    }

}

6. throws 和 throws之间的区别

throws：用在方法声明部分，表示此方法有可能出现某种类型异常，此方法不处理异常，谁调用谁处理

throw：在方法体中，抛出一个具体的异常对象，该方法终止，在异常对象的构造方法中自定义异常原因

五、运行期异常和编译期异常

异常分为运行期异常和编译期异常两种

1.编译时期异常（即checked异常、受检异常）

在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）XX异常，并明确督促程序员提前编写处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的代码引起的

例如：FileNotFoundException（文件找不到异常）

2.运行时期异常（即runtime异常、unchecked异常、非受检异常）

在代码编译阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确实发生了XX异常，它才能被发现。通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免。

● java.lang.RuntimeException类及它的子类都是运行时异常

比如： ArrayIndexOutOfBoundsException数组下标越界异常

ClassCastException类型转换异常

public class Demo8 {
   /*
     异常分为；
          检查期异常：在编译期间就会主动提示程序员要进行处理异常
          运行期异常：在编译期间不会主动提示程序员进行处理的异常
          区别在于异常类有没有继承RuntimeException
    */
    public static void main(String[] args) {
        try {
            methodA(new int[5]);
        }catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
            arrayIndexOutOfBoundsException.printStackTrace();
        }catch (UnsupportedEncodingException unsupportedEncodingException){
            unsupportedEncodingException.printStackTrace();
        }
        System.out.println("main");
    }

    public static void methodA(int [] a) throws ArrayIndexOutOfBoundsException, UnsupportedEncodingException{
        methodB(a);
        System.out.println("methodA");
    }

    public static void methodB(int [] a) throws ArrayIndexOutOfBoundsException,UnsupportedEncodingException{
        a[5] = 0;
    }
}

比如数组索引越界异常，ArrayIndexOutOfBoundsException类其实是继承RuntimeException类的，属于运行期异常，不提示

六、自定义异常

1.概念

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

2.作用

用自定义异常标记业务逻辑的异常，避免与标准异常混淆

3.自定义异常类

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

}

}

● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或 throws抛出

比如：

分数自定义异常：当分数不合法时抛出此类的对象；例如百分制分数，当输入小于0，大于100时抛出

public class ScoreException extends Exception{

    //根据自己的业务需求定义异常类型————自定义异常
    
    public ScoreException(String message){
       super(message);    
    }
    
}

public class Demo9 {

    public static void main(String[] args) {
      try {
          char c = level(101);
      }catch(ScoreException a){
          a.printStackTrace();
          System.out.println(a.getMessage());
      }
        System.out.println("aaaaaaaaaaaa");
    }

    public static char level(int score) throws ScoreException{
        if (score<0||score>100){
            throw new ScoreException("非法的分数");
        }
        if (score>=90&&score<=100) {
            return 'A';
        }else {
            return 'B';
        }
    }

}