Java常见异常和错误处理

た入场券 2023-10-14 10:33 29阅读 0赞

#### 目录 ####

*  1. Java.lang.NullPointerException
 *  2. Java.lang.ClassNotFoundException
 *  3. Java.lang.ArithmeticException
 *  4. Java.lang.ArrayIndexOutOfBoundsException
 *  5. Java.lang.IllegalArgumentException
 *  6. Java.lang.IllegalAccessException
 *  7. Java.lang.InstantiationException
 *  8. Java.lang.InterruptedException
 *  9. Java.lang.UnsupportedOperationException

在 Java 编程中，异常和错误处理是非常重要的一部分。Java 的异常机制可以让我们在程序运行时捕获和处理异常，从而避免程序崩溃。下面我们将介绍 Java 中常见的异常和错误，并给出代码分析。

## 1. Java.lang.NullPointerException ##

空指针异常，通常发生在试图访问一个空对象的变量、方法或空数组的元素时。例如：

String str = null;  
    System.out.println(str.length); // 会抛出 NullPointerException

解决方法是确保所访问的对象不为空，可以使用判空语句，例如：

if (str!= null) {
          
     System.out.println(str.length);  
    }

## 2. Java.lang.ClassNotFoundException ##

类未找到异常，通常发生在试图加载一个不存在的类时。例如：

Class<?> cls = Class.forName("NonExistingClass"); // 会抛出 ClassNotFoundException

解决方法是确保所加载的类存在，可以使用 try-catch 语句捕获异常，例如：

try {
          
     Class<?> cls = Class.forName("NonExistingClass");  
    } catch (ClassNotFoundException e) {
          
     e.printStackTrace();  
    }

## 3. Java.lang.ArithmeticException ##

算术异常，通常发生在进行算术运算时，例如除以 0 或取模运算时。例如：

int a = 10, b = 0;  
    int result = a / b; // 会抛出 ArithmeticException

解决方法是避免进行非法的算术运算，例如使用判空语句和判正负语句，例如：

if (b == 0) {
          
     throw new ArithmeticException();  
    }
    int result = a / b;

## 4. Java.lang.ArrayIndexOutOfBoundsException ##

数组越界异常，通常发生在访问一个不存在的数组元素时。例如：

int[] arr = new int[5];  
    System.out.println(arr[6]); // 会抛出 ArrayIndexOutOfBoundsException

解决方法是确保所访问的数组元素存在，可以使用判空语句和判大小语句，例如：

if (arr.length <= 6) {
          
     System.out.println(arr[6]);  
    } else {
          
     throw new ArrayIndexOutOfBoundsException();  
    }

## 5. Java.lang.IllegalArgumentException ##

非法参数异常，通常发生在方法传入了一个不合法或不正确的参数时。例如：

public void method(int a, String b) {
          
     if (a < 0) {
          
       throw new IllegalArgumentException();  
     }  
    }
    // 调用方法  
    method(-1, "Hello World"); // 会抛出 IllegalArgumentException

解决方法是确保所传入的参数符合方法的要求，可以使用判大小语句和判类型语句，例如：

if (a < 0) {
          
     throw new IllegalArgumentException();  
    }
    if (b == null) {
          
     throw new IllegalArgumentException();  
    }

## 6. Java.lang.IllegalAccessException ##

非法访问异常，通常发生在一个类试图访问另一个类的私有或受保护成员时。例如：

class A {
          
     private int a = 10;  
    }
    class B extends A {
          
     public void method() {
          
       System.out.println(a); // 会抛出 IllegalAccessException  
     }  
    }

解决方法是确保所访问的成员是公共的或受保护的，可以使用 getter 和 setter 方法来访问成员，例如：

class A {
          
     private int a = 10;
     public int getA() {
          
       return a;  
     }
     public void setA(int a) {
          
       this.a = a;  
     }  
    }
    class B extends A {
          
     public void method() {
          
       System.out.println(getA());  
     }  
    }

## 7. Java.lang.InstantiationException ##

实例化异常，通常发生在试图实例化一个抽象类或接口时。例如：

public abstract class A {
          
    }
    public class B extends A {
          
    }
    A a = new B(); // 会抛出 InstantiationException

解决方法是确保所实例化的类是一个具体的类，而不是抽象类或接口。可以使用抽象类的构造函数或工厂方法来创建实例，例如：

public abstract class A {
          
     public A() {
          
       // 实现抽象方法  
     }
     public static A getInstance() {
          
       return new B(); // 返回一个具体的实例  
     }  
    }
    public class B extends A {
          
     public B() {
          
       // 实现抽象方法  
     }  
    }
    A a = A.getInstance(); // 不会抛出 InstantiationException

## 8. Java.lang.InterruptedException ##

中断异常，通常发生在一个线程在等待另一个线程执行时，被中断了。例如：

Thread t1 = new Thread() {
          
     public void run() {
          
       try {
          
         Thread.sleep(1000); // 线程 1 睡眠 1 秒  
       } catch (InterruptedException e) {
          
         e.printStackTrace();  
       }  
     }  
    };
    Thread t2 = new Thread() {
          
     public void run() {
          
       t1.interrupt(); // 中断线程 1  
       try {
          
         t1.join(); // 等待线程 1 执行完毕  
       } catch (InterruptedException e) {
          
         e.printStackTrace();  
       }  
     }  
    };
    t2.start(); // 启动线程 2

解决方法是确保在等待其他线程执行时，使用 `join()` 方法而不是 `wait()` 方法，因为 `wait()` 方法可能会导致阻塞，从而引发中断异常。同时，在调用 `interrupt()` 方法中断线程时，要确保被中断的线程已经启动。

## 9. Java.lang.UnsupportedOperationException ##

不支持的操作异常，通常发生在试图对一个对象执行一个不支持的操作时。例如：

public class A {
          
     public void add(int a, int b) {
          
       System.out.println("A 类支持的加法操作");  
     }  
    }
    public class B extends A {
          
     public void add(int a, int b) {
          
       System.out.println("B 类支持的加法操作");  
     }
     public void subtract(int a, int b) {
          
       System.out.println("B 类支持的减法操作");  
     }  
    }
    B b = new B();  
    b.subtract(1, 1); // 会抛出 UnsupportedOperationException

解决方法是确保所执行的操作是该对象支持的操作。可以使用 `instanceof` 关键字和 `getClass()` 方法来检查对象的类型，例如：

if (obj instanceof A) {
          
     ((A) obj).add(1, 1);  
    } else if (obj instanceof B) {
          
     ((B) obj).subtract(1, 1);  
    } else {
          
     throw new UnsupportedOperationException();  
    }

以上介绍了 Java 中常见的异常和错误，以及相应的解决方法。在实际编程过程中，合理地使用异常处理机制可以提高代码的可维护性和可读性。