Java异常处理详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45176519/article/details/97961140

异常概念：

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

在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象，java处理异常的方式就是中断处理。

异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行。

异常体系：

异常机制其实就是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable。其下有两个子类：java.lang.Error和java.lang.Exception。平常所说的异常指java.lang.Exception。

java.lang.Throwable：类是java语言中所有错误或异常的超类。

Exception：编译期异常，进行编译java程序出现的问题。

RuntimeException：运行期异常，java程序运行过程中出现的问题。

ArrayIndexOutOfBoundsException：数组索引越界异常

IndexOutOfBoundsException

异常相当于程序得了一个小毛病，把异常处理掉，程序可以继续执行（吃点药，继续工作）

Error（错误）：相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能继续执行。

OutOfMemoryError：内存溢出的错误，超出了给JVM分配的内存。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Test001 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //System.out.println(arr[0]);
        try {//可能会出现异常的代码
            System.out.println(arr[3]);
        } catch (Exception e) {
            //异常的处理逻辑
            System.out.println(e);
        }
    }
}

异常的产生过程解析

public class Test001 {
    public static void main(String[] args) {
        //创建int类型的数组并赋值
        int[] arr = {1, 2, 3};
        int e = getElement(arr, 3);//ArrayIndexOutOfBoundsException
        System.out.println(e);

    }

    public static int getElement(int[] arr, int index) {
        int ele = arr[index];
        return ele;
    }
}

throw关键字：

可以使用throw关键字在指定的方法中抛出指定的异常。

使用格式：throw new XXXException（“异常产生的原因”）；

注意：

1.throw关键字必须写在方法的内部

2.throw关键字后面new的对象必须是Exception或者是Exception的子类对象。

3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象，throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理默认交给JVM处理（打印异常对象，中断程序），若是编译异常，就必须处理，要么throws，要么try…catch。

public class Test001 {
    public static void main(String[] args) {
        //创建int类型的数组并赋值
        int[] arr = null;
        int e = getElement(arr, 0);
        System.out.println(e);//NullPointerException,运行期异常，不用处理，默认交给JVM
    }
    public static int getElement(int[] arr, int index) {
        if (arr == null) {
            throw new NullPointerException("传递的值是空");
        }
}
        int ele = arr[index];
        return ele;
    }
}

public class Test001 {
    public static void main(String[] args) {
        //创建int类型的数组并赋值
        int[] arr = new int[3];
        int e = getElement(arr, 3);
        System.out.println(e);//ArrayIndexOutOfBoundsException
    }

    public static int getElement(int[] arr, int index) {

/*可以对传递过来的参数index进行合法性效验，
如果index的范围不在数组的索引范围内，我们就抛出数组索引越界异常，
告知方法的调用者

* */
        if (index < 0 || index > arr.length - 1) {
            throw new ArrayIndexOutOfBoundsException("数组索引越界异常");
        }
        int ele = arr[index];
        return ele;
    }
}

/*Object类中的静态方法：
public static <T>T requireNonNull(T obj):查看指定引用对象不是null
*/
public class TestObject {
    public static void main(String[] args) {
        method(null);
    }

    public static void method(Object obj) {
        //对传递过来的参数进行合法性判断
        // Objects.requireNonNull(obj);
        //Objects.requireNonNull("传递的对象的值是空")；
        if (obj == null) {
            throw new NullPointerException("传递的对象是null");
        }
    }
}

throws：异常处理的第一种方式，交给别人处理。

作用：当方法内部出现异常对象的时候，我们就必须处理这个异常对象，可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理，最终交给JVM处理，–>中断处理。

使用格式：在方法声明时使用。

修饰符返回值类型方法名（参数列表）throws{

throw new AAAException（“产生原因”）；

throw new BBBException（“产生原因”）；

}

注意事项：

1.throws关键字必须写在方法声明处。

2.throws关键字后面声明的异常必须是Exception或者是Exception的子类。

3.方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常。

如果抛出的异常有子父类关系，那么直接声明父类异常即可。

4.调用了一个声明异常的方法，我们就必须处理声明的异常。要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM，要么try…catch自己处理异常。

import java.io.FileNotFoundException;
import java.io.IOException;

public class Test01Throws {
    public static void main(String[] args) throws FileNotFoundException,IOException {
        //readFile("E:\\c.txt");
        readFile("E:\\c.txt");
        //System.out.println("后续代码");若路径不一样后续代码不能执行
    }

    /*定义一个方法，对传递的文件路径进行合法性判断，
    如果路径不是“E:\\c.txt”那么就抛出文件找不到异常对象，告知方法的调用者
    FileNotFoundException是编译异常，抛出了编译异常就必须处理这个异常
    可以使用throws继续声明抛出FileNotFoundException这个异常对象，
    让方法的调用者处理
    * */
    public static void readFile(String filename) throws IOException {
//        if (!filename.equals("E:\\.txt")) {
//            throw new FileNotFoundException("传递的文件不是E:\\c.txt");
//        }
        /*如果传递的路径不是.TXT结尾，我们就抛出IO异常对象，
        告知方法的调用者，文件的后缀名不对
        *
        * */
       if (!filename.endsWith(".txt")){
           throw new IOException("文件的后缀名不对");
       }
        System.out.println("路径没有问题，读取文件");
    }

}

try…catch:异常处理的第二种方式，自己处理异常

格式:
try{
可能产生异常的代码
}catch(定义一个异常的变量，用来接收try中抛出的异常对象){
异常的处理逻辑，怎么处理异常对象
}
…
catch(异常类名变量名){
}

注意事项：

1.try中可能抛出多个异常对象，那么可以使用多个catch语句处理。
2如果try中产生了异常，那么就会执行catch语句中的异常处理逻辑，
执行完catch中的处理逻辑，继续执行try…catch之后的代码。
如果try中没有产生异常，那么就不会执行catch语句中的异常处理逻辑，
执行完try中的代码，继续执行try…catch之后的代码

import java.io.IOException;
public class TestTryCatch {
    public static void main(String[] args) {
        try {
            readFile("E:\\\\.txt");
        }catch (IOException e){//
// try中抛出什么异常对象，catch中就定义什么异常变量，用来接收这个异常变量
            System.out.println("catch传递的后缀不是.txt");
        }
        System.out.println("后续代码");
    }
    /*如果传递的路径不是.TXT结尾，我们就抛出IO异常对象，
      告知方法的调用者，文件的后缀名不对*/
    public static void readFile(String fileName) throws IOException {

        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

Throwable

类中定义了一些查看异常的方法：
1.public String getMessage()
2.public String toString()
3.public void printStackTrace

import java.io.IOException;
public class TestTryCatch {
    public static void main(String[] args) {
        try {
            readFile("E:\\\\.txtp");
        }catch (IOException e){//
           // System.out.println(e.getMessage());//文件的后缀名不对
            //System.out.println(e.toString());//java.io.IOException: 文件的后缀名不对
            //System.out.println(e);//java.io.IOException: 文件的后缀名不对
       e.printStackTrace();//打印的异常信息最全面
        }
        System.out.println("后续代码");
    }
    public static void readFile(String fileName) throws IOException {

        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}