码文异常不要怕，一篇文章精通应对【Java】中的异常

在这里插入图片描述

个人名片：

🐼作者简介：一名大一在校生🎏 🐻‍❄️个人主页：小新爱学习. 🐼个人WeChat：hmmwx53 🕊️系列专栏：零基础学java ----- 重识c语言 🐓每日一句：星光不问赶路人，时光不负有心人！

文章目录

1. 异常💥
- 1.1 异常概述🎊
- - 1.1.1Error🐧
  - 1.1.2Exception的层次🐯
- 1.2 JVM的默认处理方案🎉
- 1.3 异常处理🐷
- 1.4 异常处理之 try... catch...（捕获异常）🦖
- 1.5 多重捕获🐶
- 1.6 异常方法（Throwable的成员方法）🦜
- 1.7 编译时异常和运行时异常的区别🐢
- 1.8 异常处理之throws🐬
- 1.9 声明自定义异常🦀
- 2.0 throw和throws的区别🐣
- 2.1 finally关键字🦋
- 2.2 通用异常✨

1. 异常💥 1.1 异常概述🎊

异常：就是程序出现了不正常的情况异常体系：在这里插入图片描述 Error：严重问题，不需要处理。 Exception：称为异常类，他表示程序本身可以处理的问题。

RuntimeException:在编译期是不检查的，出问题后，需要我们回来修改代码。
非RuntimeException：编译期间就必须处理，否则程序不能通过编译，就更不能正常运行

异常：索引越界

所有的异常类是从 java.lang.Exception 类继承的子类。在这里插入图片描述

```
 public class Throwable
```
```
      extends Object
```
```
    implements Serializable
```

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。

1.1.1Error🐧

public class Error extends Throwable

Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。

在执行该方法期间，无需在其 throws 子句中声明可能抛出但是未能捕获的 Error 的任何子类，因为这些错误可能是再也不会发生的异常条件。

1.1.2Exception的层次🐯

public class Exception extends Throwable Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。 Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外

public class RuntimeException extends Exception RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。索引越界，

1.2 JVM的默认处理方案🎉

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

把异常的名称，异常原因及异常出现的位置等信息输出在控制台
程序停止执行


public class Abnormal {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        int arr [] = {1,2,3};
        System.out.println(arr[3]);
    }
}
/*
开始
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3 异常原因
	at com.ithmm_01.Abnormal.method(Abnormal.java:11)// 异常出现的位置
	at com.ithmm_01.Abnormal.main(Abnormal.java:6)

 */

在这里插入图片描述

1.3 异常处理🐷 1.4 异常处理之 try… catch…（捕获异常）🦖

使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

格式

try
{
   // 可能出现异常的程序代码
}catch(异常类名 变量名)
{
   //Catch 块（异常的处理代码）
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

执行流程：程序从try里面的代码开始执行出现异常，会自动生成一个异常类对象，该异常类对象将被提交给java运行时系统当java运行时系统就收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理执行完成后，程序还可以继续往下执行

代码示例：

/*
try
{
   // 可能出现异常的程序代码
}catch(异常类名 变量名)
{
   //Catch 块（异常的处理代码）
}
 */
public class TryCatch {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
        try {
            int arr[] = {1, 2, 3};
            System.out.println(arr[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            //System.out.println("数组下标越界");
            e.printStackTrance();
        }
    }
}

在这里插入图片描述

1.5 多重捕获🐶

一个 try 代码块后面跟随多个 catch 代码块的情况就叫多重捕获。

多重捕获块的语法如下所示：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型3 异常的变量名3){
  // 程序代码
}

上面的代码段包含了 3 个 catch块。

可以在 try 语句后面添加任意数量的 catch 块。

如果保护代码中发生异常，异常被抛给第一个 catch 块。

如果抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。

如果不匹配，它会被传递给第二个 catch 块。

如此，直到异常被捕获或者通过所有的 catch 块。

try {
    file = new FileInputStream(fileName);
    x = (byte) file.read();
} catch(FileNotFoundException f) { // Not valid!
    f.printStackTrace();
    return -1;
} catch(IOException i) {
    i.printStackTrace();
    return -1;
}

1.6 异常方法（Throwable的成员方法）🦜

下面的列表是 Throwable 类的主要方法:

方法名说明public String getMessage()返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。public Throwable getCause()返回一个 Throwable 对象代表异常原因。public String toString()返回此 Throwable 的简短描述。public void printStackTrace()将此 Throwable 及其回溯打印到标准错误流。。public StackTraceElement [] getStackTrace()返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。public Throwable fillInStackTrace()用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。 1.7 编译时异常和运行时异常的区别🐢

Java中的异常被分为两大类：编译时异常和运行时异常，也称为受检异常和非受检异常异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。- 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

编译时异常: 最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。必须显示处理，否则程序就会发生错误，无法通过编译
运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。无需显示处理，也可以和编译异常一样处理
错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

运行时异常：

    public static void main(String[] args) {
        method();
    }
    //运行时异常
    public static void method(){
        try {
            int arr[] = {1, 2, 3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
        }catch(ArrayIndexOutOfBoundsException e){
           e.printStackTrace();
        }
    }
}

在这里插入图片描述

 public static void main(String[] args) {
        method1();
    }
    //编译时异常
    public static void method1(){
        try {
            String s = "2022-06-20";
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date p = sdf.parse(s);
            System.out.println(p);
        }catch(ParseException e){
            e.printStackTrace();
        }

    }

在这里插入图片描述

1.8 异常处理之throws🐬

     格式： throws   异常类名：

注意：这个格式是跟在方法的括号后面的

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。下面方法的声明抛出一个 RemoteException 异常：

import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

一个方法可以声明抛出多个异常，多个异常之间用逗号隔开。

例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：

import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

总结：

编译时异常必须进行处理，两种处理方案：try …catch …或者throws，如果采用throws这种方案，将来谁调用处理谁（还是try…catch…）
运行时异常可以不处理，出问题后，需要我们回来修改代码

1.9 声明自定义异常🦀

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。格式：

public class 异常类名 extends Exception{ 无参构造带参构造 }

只继承Exception 类来创建的异常类是检查性异常类。

下面的 InsufficientFundsException 类是用户定义的异常类，它继承自 Exception。

一个异常类和其它任何类一样，包含有变量和方法。范例：


public class ScoreException extends Exception {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}

代码示例：


public class ScoreException extends Exception {
    public ScoreException() {
    }

    public ScoreException(String message) {
        super(message);
    }
}


public class Teacher {
    public  void checkScore(int score) throws ScoreException {
        if(score  100){
            throw new ScoreException("分数异常，范围0-100");
        }else{
            System.out.println("分数正常");
        }
    }
}


import java.util.Scanner;

public class TeacherDemo {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入学生成绩： ");
       int score = s.nextInt();

       Teacher t = new Teacher();
       try {
           t.checkScore(score);
       }catch(ScoreException e ){
           e.printStackTrace();
       }
    }
}

在这里插入图片描述

2.0 throw和throws的区别🐣 throwsthrow用在方法声明之后，跟的是异常类名用在方法体内，跟的是异常对象名表示抛出异常，由该方法的调用者来处理表示抛出异常，由方法体内语句处理表示出现异常的一种可能，并不一定会方法这种异常执行throw一定抛出了某种异常 2.1 finally关键字🦋

finally 关键字用来创建在 try 代码块后面执行的代码块。

无论是否发生异常，finally 代码块中的代码总会被执行。

在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

代码示例：

public class ExcepTest{
  public static void main(String args[]){
    int a[] = new int[2];
    try{
       System.out.println("Access element three :" + a[3]);
    }catch(ArrayIndexOutOfBoundsException e){
       System.out.println("Exception thrown  :" + e);
    }
    finally{
       a[0] = 6;
       System.out.println("First element value: " +a[0]);
       System.out.println("The finally statement is executed");
    }
  }
}

控制台输出： Exception thrown :java.lang.ArrayIndexOutOfBoundsException: 3 First element value: 6 The finally statement is executed

注意下面事项：

catch 不能独立于 try 存在。
在 try/catch 后面添加 finally 块并非强制性要求的。
try 代码后不能既没 catch 块也没 finally 块。
try, catch, finally 块之间不能添加任何代码。

2.2 通用异常✨

在Java中定义了两种类型的异常和错误。

JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。在这里插入图片描述

码文异常不要怕，一篇文章精通应对【Java】中的异常

最近更新

热门博客

[ 申请 ]友情链接：