Java常见异常和错误处理

在 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 中常见的异常和错误，以及相应的解决方法。在实际编程过程中，合理地使用异常处理机制可以提高代码的可维护性和可读性。