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

个人名片：

🐼作者简介：一名大一在校生🎏 🐻‍❄️个人主页：小新爱学习.

🕊️系列专栏：零基础学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 <0 ||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的区别🐣

throws	throw
用在方法声明之后，跟的是异常类名	用在方法体内，跟的是异常对象名
表示抛出异常，由该方法的调用者来处理	表示抛出异常，由方法体内语句处理
表示出现异常的一种可能，并不一定会方法这种异常	执行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 类。

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

文章目录

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 通用异常✨

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method