Java中常见的异常都有哪些?做Java项目时遇见异常怎么处理

在Java中，有多种异常类型，可以根据异常的来源和性质进行分类。以下是一些常见的Java异常类型以及对应的解决办法示例：

1.NullPointerException（空指针异常）：

空指针异常通常发生在尝试访问空引用对象的成员（如方法、字段）或进行空引用上的操作时。下面是一个简单的Java代码示例，可能会引发空指针异常：

public class NullPointerExceptionExample {
    public static void main(String[] args) {
        String str = null;
        int length = str.length(); // 这行代码将引发NullPointerException
    }
}

在上面的示例中，我们将一个空引用赋值给了字符串变量 str，然后尝试调用 str 的 length() 方法。由于 str 是空引用，无法调用为空对象的方法，因此会抛出空指针异常。

为了避免空指针异常，可以在使用前先进行空引用的检查或者使用Java 8 引入的 Optional 类来处理可能为空的引用。下面是一个使用 Optional 类的示例代码：

import java.util.Optional;

public class NullPointerExceptionExample {
    public static void main(String[] args) {
        String str = null;
        Optional<String> optionalStr = Optional.ofNullable(str);
        int length = optionalStr.orElse("").length();
        System.out.println("Length: " + length);
    }
}

在上述示例中，我们使用 Optional.ofNullable() 方法创建一个可能为空的引用，并使用 orElse() 方法指定如果引用为空时的默认值。通过这种方式，我们可以避免使用空引用调用方法引发空指针异常。

2.ArrayIndexOutOfBoundsException（数组越界异常）：

在处理ArrayIndexOutOfBoundsException（数组越界异常）时，产生的原因是尝试访问数组中不存在的索引位置。解决办法是在访问数组元素之前，确保索引值在合法范围内。

当使用数组时，需要注意数组的索引范围。数组的索引从0开始，直到数组长度减一。如果尝试访问不存在的索引位置，就会抛出ArrayIndexOutOfBoundsException异常。

以下是一个示例代码，用于演示如何避免数组越界异常：

public class ArrayIndexOutOfBoundsExceptionExample {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        // 遍历数组并打印元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println("Element at index " + i + ": " + arr[i]);
        }

        // 可能导致数组越界的操作
        // 访问数组的第 6 个元素，虽然数组长度为 5
        // 将引发 ArrayIndexOutOfBoundsException 异常
        int index = 5;
        int element = arr[index];
        System.out.println("Element at index " + index + ": " + element);
    }
}

在上述示例代码中，我们首先使用一个循环遍历数组并打印每个元素。然后，我们尝试访问索引为5的元素，虽然数组的长度只有5。这将导致ArrayIndexOutOfBoundsException异常的抛出。

为避免这种异常，应始终确保索引值在合法范围内。例如，在访问数组元素之前，使用条件语句（例如if语句）检查索引是否越界。

if (index >= 0 && index < arr.length) {
    // 在合法范围内访问数组元素
    int element = arr[index];
    System.out.println("Element at index " + index + ": " + element);
} else {
    // 处理索引越界的情况
    System.out.println("Invalid index: " + index);
}

通过这种方式，我们可以有效地避免数组越界异常。

3.IllegalArgumentException（非法参数异常）：

当使用非法或不合适的参数调用方法时，可能会抛出IllegalArgumentException（非法参数异常）。这种异常表示方法的参数不满足预期的条件和限制。

以下是一个示例代码，说明如何处理IllegalArgumentException异常：

public class IllegalArgumentExceptionExample {
    public static void main(String[] args) {
        int age = -5;

        try {
            validateAge(age);
            System.out.println("Age is valid: " + age);
        } catch (IllegalArgumentException e) {
            System.out.println("Invalid age: " + e.getMessage());
        }
    }

    public static void validateAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Age must be between 0 and 150");
        }
    }
}

在上述示例中，我们定义了一个validateAge()方法，用于验证年龄是否合法。如果年龄小于0或大于150，则抛出IllegalArgumentException异常，其中包含相应的错误消息。

在main()方法中，我们通过传递一个负数（-5）作为年龄参数来调用validateAge()方法。由于参数不在合法的范围内，方法会抛出IllegalArgumentException异常。在catch块中，我们捕获并处理该异常，并打印错误消息。

要处理IllegalArgumentException异常，可以使用try-catch块捕获异常，并在catch块中执行适当的操作，例如打印错误消息、记录日志或采取其他处理措施。

在处理非法参数异常时，还可以考虑以下几点：

• 在方法设计和实现中，对参数进行适当的验证和检查，以防止非法参数的出现。
• 提供明确的错误消息，以便更容易地识别和解决问题。
• 在方法的文档注释中清楚地说明参数的预期条件和限制。

4.ArithmeticException（算术异常）：

ArithmeticException（算术异常）是在执行算术运算过程中发生错误时抛出的异常。它通常是由于以下情况之一造成的：

• 除法运算时除数为零。
• 对整数进行求模（取余）运算，而模数为零。

下面是一个示例代码，用于演示如何处理ArithmeticException异常：

public class ArithmeticExceptionExample {
    public static void main(String[] args) {
        int dividend = 10;
        int divisor1 = 2;
        int divisor2 = 0;

        try {
            int result1 = dividend / divisor1;
            System.out.println("Result 1: " + result1);

            int result2 = dividend / divisor2; // 将抛出 ArithmeticException 异常
            System.out.println("Result 2: " + result2); // 不会被执行
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

在上述示例中，我们进行了两次除法运算。在第一个除法运算中，除数 divisor1 不为零，因此不会抛出异常。在第二个除法运算中，除数 divisor2 为零，这将导致抛出 ArithmeticException 异常。

通过使用 try-catch 块，我们可以捕获并处理 ArithmeticException 异常。在 catch 块中，我们打印异常的错误消息。

为了避免 ArithmeticException 异常，在进行除法运算或求模运算之前，可以进行以下一些预防措施：

• 在进行除法运算时，确保除数不为零。可以通过if语句检查除数是否为零来实现。
• 在进行求模运算时，确保模数不为零。同样，可以使用条件语句检查模数是否为零。

if (divisor != 0) {
    // 进行除法运算或求模运算
} else {
    // 处理除数为零的情况
}

通过这种方式，我们可以避免或捕获并处理 ArithmeticException 异常，从而确保算术运算的正确性和可靠性。

5.NumberFormatException（数字格式异常）：
NumberFormatException（数字格式异常）是在尝试将一个字符串转换为数字类型时发生格式不正确的情况下抛出的异常。它通常发生在以下情况下：

• 字符串包含非数字字符（除了可接受的符号、小数点或指数符号）。
• 字符串表示的数字超出了数字类型的范围。

下面是一个示例代码，演示如何处理NumberFormatException异常：

public class NumberFormatExceptionExample {
    public static void main(String[] args) {
        String numberStr1 = "123";
        String numberStr2 = "abc";

        try {
            int number1 = Integer.parseInt(numberStr1);
            System.out.println("Number 1: " + number1);

            int number2 = Integer.parseInt(numberStr2); // 将抛出 NumberFormatException 异常
            System.out.println("Number 2: " + number2); // 不会被执行
        } catch (NumberFormatException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

在上述示例中，我们尝试将两个字符串 numberStr1 和 numberStr2 转换为整数类型。第一个字符串 numberStr1 可以成功转换为整数，而第二个字符串 numberStr2 包含非数字字符，这将导致抛出 NumberFormatException 异常。

通过使用 try-catch 块，我们可以捕获并处理 NumberFormatException 异常。在 catch 块中，我们打印异常的错误消息。

为避免 NumberFormatException 异常，可以在尝试将字符串转换为数字之前进行预防措施。一种方法是使用 parseInt() 方法之前，先使用正则表达式（\\d+）或其他验证机制确保字符串只包含数字字符。

if (numberStr.matches("\\d+")) {
    int number = Integer.parseInt(numberStr);
    // 进行后续操作
} else {
    // 处理字符串不是数字的情况
}

另外，要确保字符串表示的数字在目标数字类型的范围内。例如，在转换为整数时，确保它不超过 Integer 类型的范围。

try {
    int number = Integer.parseInt(numberStr);
    // 进行后续操作
} catch (NumberFormatException e) {
    // 处理格式不正确或超出范围的情况
}

通过这些方法，我们可以避免或捕获并处理 NumberFormatException 异常，从而确保正确地进行数字字符串到数字类型的转换。

6.IOException（输入输出异常）：

IOException可能由以下情况之一引起：

-读取文件或流时发生错误。
-写入文件或流时发生错误。
-找不到文件或文件不可读。
-文件或流被意外关闭。
解决办法：使用try-catch块捕获异常，处理或报告错误，并确保关闭打开的资源。
7.ClassNotFoundException（类未找到异常）：

产生原因：尝试加载不存在的类。
为了避免 ClassNotFoundException异常，需要确保以下几点：

-类的路径和名称正确。
-类所属的包已正确添加到类路径中。
-类所依赖的其他类也正确地加载和存在。
如果确保上述条件都满足，就可以避免 ClassNotFoundException 异常的发生。
8.InterruptedException（线程中断异常）：

InterruptedException（线程中断异常）是在进行多线程编程时，当一个线程处于等待、睡眠或被阻塞状态，并且被另一个线程中断时抛出的异常。它是 java.lang 包中的一个受检查异常。

InterruptedException 通常发生在以下情况下：

• 当一个线程调用了另一个线程的 interrupt() 方法时，被调用线程可能抛出该异常。
• 当一个线程处于等待状态（如 Object.wait()、Thread.sleep()等），而它被中断时，也会抛出该异常。

下面是一个示例代码，展示如何处理 InterruptedException 异常：

public class InterruptedExceptionExample {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();

        // 主线程休眠一段时间
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }

        // 中断线程
        t.interrupt();
    }

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("Running...");
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                System.out.println("Exception caught: " + e.getMessage());
            }

            System.out.println("Thread finished.");
        }
    }
}

在上述示例中，我们创建了一个线程 t，并在 main 方法中启动它。主线程休眠了2秒钟后，调用 t 对象的 interrupt() 方法中断线程。

在 MyRunnable 的 run() 方法中，我们使用一个循环来执行一些操作。在每次循环迭代之后，我们使用 Thread.sleep() 方法使线程休眠1秒钟。如果线程在休眠期间被中断，将抛出 InterruptedException 异常。

通过使用 try-catch 块，我们可以捕获并处理 InterruptedException 异常。在这种情况下，我们打印异常的错误消息，然后退出循环。

处理 InterruptedException 异常的一种常见模式是在 catch 块中重新设置中断标志位，以便其他部分的代码可以检查并进行适当的处理。

catch (InterruptedException e) {
    System.out.println("Exception caught: " + e.getMessage());
    Thread.currentThread().interrupt(); // 重新设置中断标志位
}

通过这种方式，我们可以在捕获 InterruptedException 异常后，保留线程的中断状态，以便其他代码可以检测并采取适当的措施。

请注意，在线程的执行代码中，需要定期检查线程的中断状态，并在适当的时候退出循环或返回，以响应中断请求。

希望这个示例能帮助您理解和处理 InterruptedException 异常

这只是一些常见的Java异常类型和对应的解决办法示例。在编程过程中，使用try-catch块可以捕获异常并进行适当的处理，保证程序的健壮性和可靠性。同时，编写良好的代码，进行参数检查和错误处理，可以进一步预防异常的发生。针对具体的业务逻辑和使用场景，可能还要处理其他类型的异常。
希望以上内容对您有所帮助,大家有什么问题欢迎在下面留言!