Java 中常见的 Exception 有哪些

Java 是一种广泛使用的编程语言，它的强大和流行程度在很大程度上归功于它的异常处理机制。异常是在程序执行期间出现的错误或意外情况。在 Java 中，异常是通过抛出和捕获异常对象来处理的。在本文中，我们将介绍 Java 中的一些常见异常类型及其使用方法。
在这里插入图片描述

文章目录

NullPointerException

NullPointerException 是 Java 中最常见的异常之一。它通常表示试图访问 null 引用对象时发生的错误。例如，以下代码会抛出 NullPointerException 异常：

String str = null;
int length = str.length();

解决方法是在使用对象前先进行非空判断：

if (str != null) {
    int length = str.length();
}

ArrayIndexOutOfBoundsException

当访问数组时，如果使用了无效的索引，则会抛出 ArrayIndexOutOfBoundsException 异常。例如，以下代码会抛出异常：

int[] arr = new int[5];
int i = arr[5];

解决方法是确保在访问数组元素时使用的索引在有效范围内：

int[] arr = new int[5];
if (index < arr.length) {
    int i = arr[index];
}

ClassCastException

在 Java 中，如果尝试将一个对象强制转换为另一个不兼容的类型，则会抛出 ClassCastException 异常。例如，以下代码会抛出异常：

Object obj = new Integer(100);
String str = (String) obj;

解决方法是在进行类型转换之前进行类型检查：

Object obj = new Integer(100);
if (obj instanceof String) {
    String str = (String) obj;
}

ArithmeticException

如果在算术运算中出现了除以零的情况，则会抛出 ArithmeticException 异常。例如，以下代码会抛出异常：

int i = 1 / 0;

解决方法是在进行除法运算之前，先进行零判断：

if (divisor != 0) {
    int i = dividend / divisor;
}

IllegalArgumentException

如果传递给方法的参数不符合预期的条件，则会抛出 IllegalArgumentException 异常。例如，以下代码会抛出异常：

void printName(String name) {
    if (name == null || name.isEmpty()) {
        throw new IllegalArgumentException("Name cannot be empty");
    }
    System.out.println(name);
}

解决方法是在调用方法之前，确保传递的参数符合预期的条件：

String name = "John";
if (name != null && !name.isEmpty()) {
    printName(name);
}

FileNotFoundException

如果尝试打开不存在的文件，则会抛出 FileNotFoundException 异常。例如，以下代码会抛出异常：

File file = new File("nonexistent.txt");
Scanner scanner = new Scanner(file);

解决方法是确保文件存在并且路径正确：

File file = new File("existing.txt");
if (file.exists()) {
    Scanner scanner = new Scanner(file);
}

IOException

如果在进行输入输出操作时出现错误，则会抛出 IOException 异常。例如，以下代码会抛出异常：

try {
    InputStream input = new FileInputStream("file.txt");
    OutputStream output = new FileOutputStream("nonexistent.txt");
    byte[] buffer = new byte[1024];
    int length;
    while ((length = input.read(buffer)) > 0) {
        output.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
}

解决方法是在进行输入输出操作时，使用 try-catch 块捕获异常：

try {
    InputStream input = new FileInputStream("file.txt");
    OutputStream output = new FileOutputStream("existing.txt");
    byte[] buffer = new byte[1024];
    int length;
    while ((length = input.read(buffer)) > 0) {
        output.write(buffer, 0, length);
    }
} catch (IOException e) {
    e.printStackTrace();
}

InterruptedException

如果在进行多线程编程时，线程被中断，则会抛出 InterruptedException 异常。例如，以下代码会抛出异常：

try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

解决方法是在进行线程操作时，使用 try-catch 块捕获异常：

try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

NoSuchMethodException

如果调用了不存在的方法，则会抛出 NoSuchMethodException 异常。例如，以下代码会抛出异常：

class MyClass {
    public void method1() {
        System.out.println("Method 1");
    }
}

MyClass obj = new MyClass();
Method method2 = obj.getClass().getMethod("method2");

解决方法是确保调用的方法存在：

class MyClass {
    public void method1() {
        System.out.println("Method 1");
    }
}

MyClass obj = new MyClass();
try {
    Method method2 = obj.getClass().getMethod("method2");
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}

OutOfMemoryError

如果程序试图分配过多的内存，则会抛出 OutOfMemoryError 异常。例如，以下代码会抛出异常：

List<Integer> list = new ArrayList<>();
while (true) {
    list.add(1);
}

解决方法是优化代码，减少内存使用量：

List<Integer> list = new ArrayList<>();
while (true) {
    try {
        list.add(1);
    } catch (OutOfMemoryError e) {
        e.printStackTrace();
        break;
    }
}

以上是 Java 中常见的异常类型及其解决方法。在实际编程中，我们还可能会遇到其他类型的异常。无论遇到哪种异常，我们都应该在代码中使用 try-catch 块捕获异常，并进行适当的处理，以保证程序的稳定性和可靠性。

附上完整代码和截图：

import java.io.*;
import java.lang.reflect.*;
import java.util.*;

public class ExceptionDemo {
    public static void main(String[] args) {
        // NullPointerException
        String str = null;
        try {
            int length = str.length();
        } catch (NullPointerException e) {
            e.printStackTrace();
        }

        // ArrayIndexOutOfBoundsException
        int[] arr = new int[5];
        int index = 5;
        try {
            int i = arr[index];
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }

        // ClassCastException
        Object obj = new Integer(100);
        try {
            String str2 = (String) obj;
        } catch (ClassCastException e) {
            e.printStackTrace();
        }

        // ArithmeticException
        int dividend = 1;
        int divisor = 0;
        try {
            int i = dividend / divisor;
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }

        // IllegalArgumentException
        String name = "";
        try {
            printName(name);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        }

        // FileNotFoundException
        File file = new File("nonexistent.txt");
        try {
            Scanner scanner = new Scanner(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        // IOException
        try {
            InputStream input = new FileInputStream("file.txt");
            OutputStream output = new FileOutputStream("existing.txt");
            byte[] buffer = new byte[1024];
            int length;
            while ((length = input.read(buffer)) > 0) {
                output.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // InterruptedException
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // NoSuchMethodException
        MyClass obj2 = new MyClass();
        try {
            Method method2 = obj2.getClass().getMethod("method2");
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

        // OutOfMemoryError
        List<Integer> list = new ArrayList<>();
        while (true) {
            try {
                list.add(1);
            } catch (OutOfMemoryError e) {
                e.printStackTrace();
                break;
            }
        }
    }

    static class MyClass {
        public void method1() {
            System.out.println("Method 1");
        }
    }

    static void printName(String name) {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
        System.out.println(name);
    }
}