Java面向对对象——异常处理

最新推荐文章于 2024-12-10 15:32:05 发布

liu。。。。

最新推荐文章于 2024-12-10 15:32:05 发布

阅读量178

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/qq_48186679/article/details/119061284

版权

java 专栏收录该内容

17 篇文章

订阅专栏

本文详细介绍了Java中的异常处理，包括异常的定义、异常类的来源、异常处理的方案，以及如何通过try-catch-finally语句捕获和抛出异常。异常分为运行时异常和编译异常，需要根据情况选择处理方式。强调了异常处理的重要性，旨在提高程序的稳定性和健壮性。同时，文章给出了异常处理的示例和规则，帮助开发者更好地理解和应用Java异常处理机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.什么是异常？

异常是程序中的一些错误，但并不是所以的错误都是异常，并且错误有时候是可以避免的.

异常就是指的程序在运行过程中，发生的不正常（用户操作不当、服务终止、程序BUG……）的程序无法正常运作的情况

异常处理的目的：为了提高程序的稳定性和健壮性，让程序正常的运作下去

比如，希望用户输入一个 int 类型的年龄，但是用户的输入是 abc ：

// 假设用户输入了abc：
 String s = "abc"; 
 int n = Integer.parseInt(s); // NumberFormatException!

2.异常类从哪里来？

1.是Java语言本身的一些基本异常类型
2.是用户通过继承Exception类或者其子类自定义的异常。Exception类及其子类是Throwable的一种形式，它指出了合理的y’y4程序要捕获的条件。

3.异常类处理的方案

1.抛出异常
当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息，运行时系统负责寻找处置异常的代码并执行。
2.捕获异常
在方法抛出异常之前，运行时系统将转为异常处理器，潜在的异常处理器时异常发生时依次存留在调用栈中的方法的集合。在异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。在运行时系统从发生异常的方法开始，依次会差调用栈中的方法，直到找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适的异常处理器，则运行时系统终止。

4.异常类类图

在这里插入图片描述

Throwable
它是Java语言中所以错误或异常的超类。只有当对象是此类或子类之一的示例时，才能通过Java虚拟机或者throw语句抛出。只有此类或其子类之一才可以是catch自居中的参数。

Error
是程序无法处理的错误，表示运行应用程序中叫严重的问题。大多数错误与代码编写执行者的操作无关，而表示代码运行是JVM出现问题。

Exception
是程序本身可以处理的异常。Exception类有一个重要的子类RuntimeException。RuntimeException类及其子类表示“JVM常用操作”引发的错误。

注意:异常和错误的区别:异常能被程序本身可以处理，错误是无法处理。通常, Java的异常(包括Exception和Error)分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。

运行时异常:都是RuntimeException类及其子类异常NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

非运行时异常(编译异常) :是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如l0Exception、 SQLException等以及用户自定义的Exception异常，-般情况下不自定义检查异常。

5.捕获异常

捕获异常使用 try…catch 语句，把可能发生异常的代码放到 try {…} 中，然后使用catch 捕获对应的 Exception 及其子类：

try {
		// 代码块
	} catch (XxxException e) {
		// 处理异常
	
	} catch (XxxException e) {
		// 处理异常
	
	} finally {
	
	}

5.2多catch语句

可以使用多个 catch 语句，每个 catch 分别捕获对应的 Exception 及其子类。JVM在捕获到异常后，会从上到下匹配 catch 语句，匹配到某个 catch 后，执行 catch 代码块，然后不再继续匹配。
简单地说就是：多个 catch 语句只有一个能被执行。

例如

public static void main(String[] args) { 
   try {
       process1(); 
       process2(); 
       process3(); 
   } catch (IOException e) { 
       System.out.println(e); 
   } catch (NumberFormatException e) {
        System.out.println(e); 
   } 
}

对于上面的代码， UnsupportedEncodingException 异常是永远捕获不到的，因为它是IOException 的子类。当抛出 UnsupportedEncodingException 异常时，会被 catch (IOException e) { … } 捕获并执行

存在多个 catch 的时候， catch 的顺序非常重要：子类必须写在前面。

public static void main(String[] args) { 
   try {
       process1(); 
       process2(); 
       process3(); 
   } catch (NumberFormatException e) {
        System.out.println(e); 
   } catch (IOException e) { 
       System.out.println(e); 
   } 
}

5.2.finally语句

不管是否存在异常，finally部分必须要执行
无论是否有异常发生，如果我们都希望执行一些语句.Java的 try … catch 机制还提供了 finally 语句，finally 语句块保证有无错误都会执行。

public static void main(String[] args) { 
   try {
       process1(); 
       process2(); 
       process3(); 
   } catch (NumberFormatException e) {
        System.out.println(e); 
   } catch (IOException e) { 
       System.out.println(e); 
   } finally { 
       System.out.println("END"); 
   }
}

注意 finally 有几个特点：

finally 语句不是必须的，可写可不写；
finally 总是最后执行。

如果没有发生异常，就正常执行 try { … } 语句块，然后执行 finally 。如果发生了异常，就中断执行 try { … } 语句块，然后跳转执行匹配的 catch 语句块，最后执行 finally 。
finally 是用来保证一些代码必须执行的。

某些情况下，可以没有 catch ，只使用 try … finally 结构。因为方法声明了可能抛出的异常，所以可以不写 catch

void process(String file) throws IOException { 
     try {... 
     } finally { 
          System.out.println("END"); 
     } 
 }

1.Java使用异常来表示错误，并通过 try … catch 捕获异常；
2.Java的异常是 class ，并且从 Throwable 继承；
3.Error 是无需捕获的严重错误， Exception 是应该捕获的可处理的错误；
4.RuntimeException 无需强制捕获，非 RuntimeException （Checked Exception）需强制捕获，或者用 throws 声明；
5.不推荐捕获了异常但不进行任何处理。

使用 try … catch … finally 时：
1.多个 catch 语句的匹配顺序非常重要，子类必须放在前面；
2.finally 语句保证了有无异常都会执行，它是可选的；
3.一个 catch 语句也可以匹配多个非继承关系的异常。

6.抛出异常

6.1概述

任何Java代码都可以抛出异常，如:自己编写的代码、
来自Java开发环境包中代码，或者Java运行时系统。无
论是谁，都可以通过Java的throw语句抛出异常。从方法
中抛出的任何异常都必须使用throws子句。

6.2.throw抛出异常

如果一个方法可能会出现异吊，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。

例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。

throws语句的语法格式为:

methodname throws Exception1... ExceptionN
{
)

方法名后的throws Exception1 ,xcepin…xceptionN为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。

例如:

import java.lang.Exception;  
public class TestException {  
    static void pop() throws NegativeArraySizeException {  
        // 定义方法并抛出NegativeArraySizeException异常  
        int[] arr = new int[-3]; // 创建数组  
    }  
  
    public static void main(String[] args) { // 主方法  
        try { // try语句处理异常信息  
            pop(); // 调用pop()方法  
        } catch (NegativeArraySizeException e) {  
            System.out.println("pop()方法抛出的异常");// 输出异常信息  
        }  
    }  
}

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向.上抛出,但最终要有能够处理该异常的调用者。pop方法没有处理异常
NegativeArraySizeException,而是由main函数来处理。

6.3.Throws抛出异常的规则

1)如果是不可查异常(unchecked exception)，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
2)必须声明方法可抛出的任何可查异常。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

例如:

void method1() throws IOException{}  //合法    
//编译错误，必须捕获或声明抛出IOException    
void method2(){    
  method1();    
}    
//合法，声明抛出IOException    
void method3()throws IOException {    
  method1();    
}    
//合法，声明抛出Exception，IOException是Exception的子类    
void method4()throws Exception {    
  method1();    
}    
//合法，捕获IOException    
void method5(){    
 try{    
    method1();    
 }catch(IOException e){…}    
}    
//编译错误，必须捕获或声明抛出Exception    
void method6(){    
  try{    
    method1();    
  }catch(IOException e){throw new Exception();}    
}    
//合法，声明抛出Exception    
void method7()throws Exception{    
 try{    
  method1();    
 }catch(IOException e){throw new Exception();}    

}

判断一个方法可能会出现异常的依据如下:
1)方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
2)调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1)方法，method1()方法声明抛出I0Exception,因此，在method3()方法中可能会出现IOException。

使用throw抛出异常

throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块
中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。

该语句的语法格式为:

throw new exceptionname;

要注意的是，throw拋出的只能够是可拋出类Throwable或者其子类的实例对象。下面的操作是错误的: throw new String(“exception’”);这是因为String不是
Throwahle类的子举。
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。如果所有方法都层层.上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException, 则该方法的调用者可选择处理该异常。

package Test;  
import java.lang.Exception;  
public class TestException {  
    static int quotient(int x, int y) throws MyException { // 定义方法抛出异常  
        if (y < 0) { // 判断参数是否小于0  
            throw new MyException("除数不能是负数"); // 异常信息  
        }  
        return x/y; // 返回值  
    }  
    public static void main(String args[]) { // 主方法  
        int  a =3;  
        int  b =0;   
        try { // try语句包含可能发生异常的语句  
            int result = quotient(a, b); // 调用方法quotient()  
        } catch (MyException e) { // 处理自定义异常  
            System.out.println(e.getMessage()); // 输出异常信息  
        } catch (ArithmeticException e) { // 处理ArithmeticException异常  
            System.out.println("除数不能为0"); // 输出提示信息  
        } catch (Exception e) { // 处理其他异常  
            System.out.println("程序发生了其他的异常"); // 输出提示信息  
        }  
    }  
  
}  
class MyException extends Exception { // 创建自定义异常类  
    String message; // 定义String类型变量  
    public MyException(String ErrorMessagr) { // 父类方法  
        message = ErrorMessagr;  
    }  
  
    public String getMessage() { // 覆盖getMessage()方法  
        return message;  
    }  

} 
运行结果
 除数不能为0