Java 中的异常（Exception）

最新推荐文章于 2024-09-18 16:24:43 发布

不爱吃杨桃

最新推荐文章于 2024-09-18 16:24:43 发布

阅读量934

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_77681226/article/details/137413377

版权

Java 异常概述

异常：

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

JVM的非正常停止。

• 异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文

件，根本不能运行。

异常的抛出机制

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

Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型

的对象，并且抛出。

然后程序员可以捕获到这个异常对象，并处理；

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

如何对待异常

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

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

另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和

错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的

检测、以及异常的处理，保证代码的健壮性。

java异常体系结构

● Throwable

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

Throwable 中的常用方法：

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

包含了异常的类型、异常的原因、异常出现的位置、在开发和调试阶段都得使用 printStackTrace 。

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

Throwable可分为两类：Error和Exception。

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

Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等

严重情况。一般不编写针对性的代码进行处理。

例如：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存

溢出，简称OOM）。

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对

性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。

常见的异常

Error

堆溢出: OutOfMemoryError

栈溢出: StackOverflowError

异常--运行时异常

数组越界异常

类型转换异常

数字格式化异常

空指针异常

算术异常

public class Demo1 {
    /*
    异常：程序在运行过程中出现的不正常情况
        例如用户输入数据错误，导致数据被程序删除；网络传输的过程中突然断网出现异常
        ，导致jvm(虚拟机)停止运行，后续程序无法运行

        注意：代码写错了不算异常问题

        java中默认的异常处理机制：将出现的异常，用不同的类型分类，为每种异常封装一个类来进行表示，
            当出现某种类型的异常情况时，会抛出此类的对象，然后终止虚拟机的运行

        使用异常处理机制，对程序运行过程中出现的异常情况进行捕捉处理

     */
    public static void main(String[] args) {
        /*int a = 10;
        int b = 0;
        System.out.println(a/b);
        除数为0    ArithmeticException     算术异常
*/
        /*
        int[] c = new int[2];
        c[3] = 0;
        ArrayIndexOutOfBoundsException    数组索引越界异常
        */

        /*
        String s = "abc";
        s.charAt(4);
        StringIndexOutOfBoundsException    字符串索引异常
        */

        /*
        Object In = new Integer(12);
        String s = (String)In;
        ClassCastException      类型转换异常
        */

        /*
        Integer.parseInt("abc");
        将字符串参数解析为带符号的十进制整数。
        字符串中的字符都必须是十进制数字，
        除了第一个字符可能是ASCII减号'-' （ '\u002D' ）以指示负值或ASCII加号'+' （ '\u002B' ）以指示正值。
        NumberFormatException       数字格式化异常
        */

        /*
        String s = null;
        s.length();
        NullPointerException        空指针异常：尝试访问空引用或未初始化的对象时会抛出，应在使用对象前进行非空判断
        */
    }
}

异常处理

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

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

finally、throw、throws

• 基本语法

try{

可能会发生异常的代码

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

异常处理代码

}finally{

必须执行代码

}

● try

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

try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将

跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代

码放到try块中，因为随时可能会中断执行。

● catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，

一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类

的顺序写，否则有编译错误

捕获异常的有关信息：

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

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

• printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的

位置。返回值void。

● finally

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

finally{

必须执行的逻辑

}

public class Demo2 {
    public static void main(String[] args) {
        /*
        异常处理：
            在编码时，就针对可能出现问题的代码(经验问题)预习写一些处理机制，
            程序运行
            出现异常
            执行处理机制
            继续运行后续的程序
        try{
        编写可能出现异常的代码
        }catch(获取异常类型){
        处理机制
        }finally{
            finally代码块中的内容总能执行，一定会执行
        }
         */
        try {
            int a = 10;
            int b = 0;
            int c = a / b;
        }catch (ArithmeticException ai){
            ai.printStackTrace();//打印异常信息到控制台，一般在开发调试阶段使用，便于开发人员进行异常定位
            System.out.println("算术异常");
        }
    }
}

public class Demo4 {
    public static void main(String[] args) {
        try {
//            int num = Integer.parseInt("10a");
            
            int[] a = new int[5];
            for (int i = 0; i <= a.length; i++) {
                System.out.println(a[i]);
            }
        }catch (NumberFormatException nf){
            nf.printStackTrace();
            System.out.println("数字格式化异常"+nf.getMessage());//getMessage拿出异常原因
        }catch(ArrayIndexOutOfBoundsException ai){
            ai.printStackTrace();
            System.out.println("数组索引越界"+ai.getMessage());
        }catch (Exception e){//多态的用法，如果没有找到对应的异常类型，则用父类直接捕获任意类型的异常，但必须放在最后
            e.printStackTrace();
            System.out.println("系统繁忙，请稍后重试");
        }
    }
}

finally的三个应用场景

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo5 {
    public static void main(String[] args) throws IOException {
        /*try{
            int num = Integer.parseInt("100a");
        }catch(ArrayIndexOutOfBoundsException ai){
            System.out.println("索引越界");
        }finally {//场景一、finally  中的代码块始终会运行，无论会不会捕捉到异常，但是后面的代码无法运行
            System.out.println("pppppppppppppppppppppppppp");
        }*/

        FileInputStream in = null;
        try{
            in = new FileInputStream("H:/Download");//如果找不到文件，系统会异常
            while (in.read()!=-1){

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            if(in!=null){//场景二、finally    确保在出现异常的情况下，仍可以将流对象关闭掉
                in.close();
            }
        }
    }
}

public class Demo6 {

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

    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 {//场景三 finally   无论在try还是catch中，在执行return之前必须执行finally中的代码
            System.out.println("关闭流操作");
        }
    }
}

● throws,定义一个方法的时候可以使用throws关键字声明,表示此方法

不处理异常，而交给方法调用处进行处理。

例如:

public void test throws 异常1，异常2，异常3{

}

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

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

继续使用throws声明。

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

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

对象.

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Demo7 {
    public static void main(String[] args) {
        methodA(new int[5]);
        System.out.println("main");
    }
    public static void methodA(int[] a) {
        try {
            methodB(a);
            System.out.println("methodA");
            FileInputStream inputStream = new FileInputStream("");
        }catch (FileNotFoundException f){
            f.printStackTrace();
        }
    }
    /*
    用methodB方法表示一个底层方法
    throws  异常类型 表示此方法可能会出现的异常，并且该方法不会处理异常，而是谁调用谁进行处理

    异常(Exception):
    检查期异常  在编译期间如果出现异常会主动提示程序员
    运行期异常  在编译期间如果出现异常不会主动提示程序员，只有在运行时会有提示
    两者的区别在于异常类是否继承的是RuntimeException,继承的是运行期
     */

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

public class Demo8 {
    public static void main(String[] args) {
        try{
            test(101);
        }catch (ArithmeticException ae){
            ae.printStackTrace();
            System.out.println(ae.getMessage());
        }
        System.out.println("pppppppppppppppppppppp");
    }
    /*
        throws 在声明方法部分，表明该方法可能会出现某种类型的异常，该方法不进行处理，谁调用方法谁处理

        throw  抛出一个具体的异常对象，该方法运行终止，在异常对象中的构造方法中进行自定义异常原因
     */
    public static void test(int a)throws ArithmeticException{
        if(a<0||a>100){
            throw new ArithmeticException("非法的分数");//当不满足某些条件时，系统会主动抛出异常对象，终止此方法继续执行下去，在异常构造方法中传入异常原因
        }
        else {
            System.out.println("正常的分数");
        }
    }
}

运行期异常和编译期异常

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

● 编译时期异常（即checked异常、受检异常）：

在代码编译阶段，编译器就能明

确警示当前代码可能发生（不是一定发生）XX异常，并明确督促程序员提前编写

处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判

定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的

代码引起的,例如：FileNotFoundException（文件找不到异常）。

● 运行时期异常（即runtime异常、unchecked异常、非受检异常）：

在代码编译

阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何

提示。只有等代码运行起来并确实发生了XX异常，它才能被发现。通常，这类异

常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免。

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

ArrayIndexOutOfBoundsException数组下标越界异常，

ClassCastException类型转换异常。

自定义异常

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

子类

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

● 自定义异常类

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

public 异常类名(String msg){

super(msg);

}

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

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

throws抛出

public class gradesException extends Exception{

    //根据自己业务的需求，对异常类型的自定义 ----  自定义异常

    /*
    对分数的自定义
    超出100 小于0 时为异常现象
     */
    public gradesException(String message) {
        super(message);
    }
}

public  class Demo9 {
    public static void main(String[] args) {
        try{
            text(101);
        } catch (gradesException e) {
            e.printStackTrace();
        }
    }
    public static void text(int a)throws gradesException{
        if (a>100||a<0){
            throw new gradesException("分数错误");
        }
        else {
            System.out.println("分数正确");
        }
    }
}