前言

在Java编程中，异常处理是一种重要的机制，用于处理程序运行时可能出现的错误和异常情况。异常处理机制可以帮助开发者优雅地处理异常，提高程序的健壮性和可靠性。

提示：以下是本篇文章正文内容，下面案例可供参考

1.java异常处理机制

• java中所有错误的超类为:Throwable。其下有两个子类:Error和Exception
• Error的子类描述的都是系统错误，比如虚拟机内存溢出等
• Exception的子类描述的都是程序错误，比如空指针，下表越界等
• 通常我们程序中处理的异常都是Exception
  

2.try-catch

package exception;public class TryCatchDemo {    public static void main(String[] args) {        System.out.println("程序开始了...");                try {//            String str = null;//            String str = "";            String str = "a";                    System.out.println(str.length());//抛出空指针异常            System.out.println(str.charAt(0));            System.out.println(Integer.parseInt(str));                        System.out.println("!!!!!!!!!!!!!!");//        }catch(NullPointerException e){//            //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug//            System.out.println("出现了空指针，并解决了!");//        }catch(StringIndexOutOfBoundsException e){//            System.out.println("处理字符串下标越界问题!");//        }                }catch(NullPointerException|StringIndexOutOfBoundsException e){            System.out.println("处理空指针或下标越界!");                }catch(Exception e){            System.out.println("反正就是出了个错!");        }        System.out.println("程序结束了...");    }}

3.finally块

finally块是异常处理机制中的最后一块

• finally可以直接跟在try语句块之后
• finally可以跟在最后一个catch块之后
• fianlly下面不能再定义catch块
  特点:
  只要程序执行到异常处理机制中(执行到try语句块中)，无论try中的代码是否出现异常，finally最终都必定执行
  作用:
  通常用来执行释放资源这一类操作。例如IO操作完毕后的流关闭。
  例

package exception;public class FinallyDemo {    public static void main(String[] args) {        System.out.println("程序开始了");        try {            String str = "null";            System.out.println(str.length());            return;//结束方法，结束前finally还是要执行的        } catch (Exception e) {            System.out.println("出错了");        }finally {            System.out.println("finally中的代码执行了");        }        System.out.println("程序结束了");    }}

在IO中的应用

package exception;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class FinallyDemo2 {    public static void main(String[] args) {        FileOutputStream fos = null;        try {            fos = new FileOutputStream("./fos.dat");            fos.write(1);        } catch (IOException e) {            System.out.println("出错了");        } finally {            try {                if(fos!=null) {                    fos.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }}

4.自动关闭特性

jdk7之后java推出了一个新特性:自动关闭特性可以更优雅的在异常处理机制中关闭IO
语法

try(   声明并初始化IO对象){   IO操作}catch(IOException e){//catch各种IO异常   ...}

例

package exception;import java.io.FileOutputStream;import java.io.IOException;public class AutoCloseableDemo {    public static void main(String[] args) {        //自动关闭特性是编译器认可的，编译后就变成FinallyDemo2的样子        try(                FileOutputStream fos = new FileOutputStream("fos.dat");        ){            fos.write(1);        } catch (IOException e) {            e.printStackTrace();        }    }}

5.throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常:

• 当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者
• 程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者
  例

package exception;public class Person {    private int age;    public int getAge() {        return age;    }    public void setAge(int age) throws Exception {        if(age<0||age>100){            //使用throw对外抛出一个异常            throw new RuntimeException("年龄不合法!");        }        this.age = age;    }}

package exception;public class ThrowDemo {    public static void main(String[] args) {        Person p = new Person();        p.setAge(10000);//符合语法，但是不符合业务逻辑要求。        System.out.println("此人年龄:"+p.getAge());    }}

6.throws关键字

throws用来在声明方法时同时声明该方法可能抛出的异常，用于通知调用方添加处理该异常的手段。
当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。
例

package exception;public class Person {    private int age;    public int getAge() {        return age;    }        public void setAge(int age) throws Exception {        if(age<0||age>100){            //使用throw对外抛出一个异常//            throw new RuntimeException("年龄不合法!");            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常            throw new Exception("年龄不合法!");        }        this.age = age;    }}

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过。 处理手段有两种:

• 使用try-catch捕获并处理这个异常
• 在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取那种取决于异常处理的责任问题。

package exception;public class ThrowDemo {    public static void main(String[] args){        System.out.println("程序开始了...");        try {            Person p = new Person();                        p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求            System.out.println("此人年龄:"+p.getAge()+"岁");        } catch (Exception e) {            e.printStackTrace();        }        System.out.println("程序结束了...");    }}

注意，永远不应当在main方法上使用throws!!

7.throws的重写规则

当一个子类重写超类含有throws声明异常抛出的方法时，针对throws的重写规则

• 允许不再抛出任何异常
• 允许仅抛出部分异常
• 允许抛出超类方法声明抛出异常的子类型异常
• 不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)
• 不允许抛出超类方法抛出异常的超类型异常
  例
  子类方法的几种重写分别解开注释就可以观察编译器是否允许该种重写方式

package exception;import java.awt.*;import java.io.FileNotFoundException;import java.io.IOException;import java.sql.SQLException;public class ThrowsDemo {    public void dosome()throws IOException, AWTException {    }}class SubClass extends ThrowsDemo{//    public void dosome()throws IOException, AWTException {//    }    //允许不再抛出任何异常//    public void dosome(){//    }    //允许仅抛出部分异常//    public void dosome()throws IOException{//    }    //允许抛出超类方法声明抛出异常的子类型异常//    public void dosome()throws FileNotFoundException {//    }    //不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)//    public void dosome()throws SQLException {//    }    //不允许抛出超类方法抛出异常的超类型异常//    public void dosome()throws Exception {//    }}

8.异常分类

• **可检测异常：**可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译

• **非检测异常：**非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常

• RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现。因此它们不受编译器检查与处理或声明规则的限制。实际上RuntimeException及其子类型表达的都是因为程序漏洞(BUG),即:逻辑不严谨等原因导致的。这类异常都是通过修复代码可完全避免的异常，因此不应当由异常处理机制来处理
  常见的RuntimeException子类

• IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数

• NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常

• ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常

• ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常

• NumberFORMatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常

9.异常api

Exception上有一些常用的方法

• void printStackTrace():用于输出当前异常的堆栈跟踪信息便于程序员找到错误根源，分析错误原因制定B计划
• String getMessage():用于获取当前错误消息多用于提示给用户或记录日志使用

例

package exception;public class ExceptionAPIDemo {    public static void main(String[] args) {        System.out.println("程序开始了");        try {            String str = "abc";            System.out.println(Integer.parseInt(str));        } catch (NumberFormatException e) {            //输出错误堆栈跟踪信息便于程序员找到错误根源，分析错误原因制定B计划            e.printStackTrace();//输出错误信息            //错误消息多用于提示给用户或记录日志使用            String message = e.getMessage();//获取错误消息            System.out.println(message);        }        System.out.println("程序结束了");    }}

10.自定义异常

自定义异常通常用来定义那些业务上的异常问题
定义自定义异常需要注意以下问题:

• 异常的类名要做到见名知义
• 需要是Exception的子类
• 提供超类异常提供的所有种类构造器

例

package exception;public class IllegalAgeException extends Exception{    public IllegalAgeException() {    }    public IllegalAgeException(String message) {        super(message);    }    public IllegalAgeException(String message, Throwable cause) {        super(message, cause);    }    public IllegalAgeException(Throwable cause) {        super(cause);    }    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {        super(message, cause, enableSuppression, writableStackTrace);    }}

package exception;public class Person {    private int age;    public int getAge() {        return age;    }        public void setAge(int age) throws IllegalAgeException {        if(age<0||age>100){            //使用throw对外抛出一个异常//            throw new RuntimeException("年龄不合法!");            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常//            throw new Exception("年龄不合法!");            //抛出自定义异常            throw new IllegalAgeException("年龄超范围:"+age);        }        this.age = age;    }}

package exception;public class ThrowDemo {    public static void main(String[] args){        System.out.println("程序开始了...");        try {            Person p = new Person();                        p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求            System.out.println("此人年龄:"+p.getAge()+"岁");        } catch (IllegalAgeException e) {            e.printStackTrace();        }        System.out.println("程序结束了...");    }}

总结:

java异常处理机制:

• 异常处理机制是用来处理那些可能存在的异常，但是无法通过修改逻辑完全规避的场景。
• 而如果通过修改逻辑可以规避的异常是bug，不应当用异常处理机制在运行期间解决！应当在编码时及时修正

try语句块用来包含可能出错的代码片段.

catch用来捕获并处理对应的异常，可以定义多个，也可以合并多个异常在一个catch中.

finally是异常的最后一块，只要程序执行到try中则必走。一般用于释放资源这类操作.

throw用于主动对外抛出异常。要么是满足语法不满足业务主动抛出异常，要么就是实际发生了异常但是不应当在当前代码片段被解决时抛出。具体情况要结合实际业务分析.

throws用于在方法声明时声明该异常的抛出，使得调用者必须处理该异常.

来源地址：https://blog.csdn.net/weixin_72847531/article/details/131949698