Java异常机制

码&

已于 2022-08-01 19:51:47 修改

阅读量168

点赞数 1

分类专栏：面向对象 Java 文章标签： java eclipse 开发语言

于 2022-07-31 10:45:00 首次发布

本文链接：https://blog.csdn.net/qq_51222096/article/details/126074958

版权

Java 同时被 2 个专栏收录

59 篇文章 0 订阅

订阅专栏

面向对象

12 篇文章 0 订阅

订阅专栏

Java异常是Java提供的用于处理程序中错误的一种机制

所谓错误是指在程序运行的过程中发生的一些异常事件。如除0溢出、数组下标越界、所需要读取的文件不存在
设计良好的程序应该在异常发生时提供处理这些错误，使得程序不会因为异常的发生而阻断或者产生不可预见的结果
Java程序的执行过程中如果出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并经被提交给Java运行时系统，这个过程称为抛出异常throw
当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这个过程称为捕获异常

Java异常处理的关键字有throws、throw、try、catch、finally共5个关键字

Java语言提供了异常处理机制，为方法的异常终止和出错处理提供了清楚的接口
   - 用来在发生运行异常时告诉程序如何控制自身的运行，以防止错误的进一步恶化
   - 每个方法必须对他可能抛出的异常进行预先声明，在定义方法时，必须声明这个方法可
   能会抛出哪一种或几种异常

Java针对可能出现的问题提供了一组异常类，顶级父类为Throwable
   getMessage
   toString
   printStackTrace

异常的分类:
   1、Error及其子类：错误，一般指的是虚拟机的错误，是由Java虚拟机生成并抛出，程序
   不能进行处理所以也不加处理，例如OutOfMemoryError内存溢出、调用栈溢出
   StackOverFlowError
   2、RuntimeException及其子类：运行时异常(非受检型异常)，是由于编程bug所导致，希望
   越早发现越好，所以不进行处理，直接中断报错即可,编程人员针对报错信息修改程序bug来解
   决问题
   3、Exception及其子类中除了RuntimeException及其子类之外的其它异常：受检型异常
   (非运行时异常),这类异常属于明知道可能出现，但是没有办法杜绝的异常。这类异常一般采用
   try/catch或者throws声明抛出的方式进行异常处理，当程序出现了非正常情况，尽量保证程
   序正常结果，而不是立即中断

   - 受检型异常：明知道存在这种异常的可能，但是没有办法杜绝，所以必须进行编码异常处理
       必须进行编码处理，否则编译失败。处理方法有2个try/catch结果或者throws声明抛出
   - 非受检型异常：这种异常不需要进行处理，发现的越早越好
       可以编码处理，也可以不用处理

Throwable类是Java异常类型的顶层父类，一个对象只有是Throwable类的（直接或者间接）实例，他才是一个异常对象，才能被异常处理机制识别

请说出至少5种常见的运行时异常类型，用于检查平常的编码量
1、ArithmeticException数学异常，/ by zero是异常的说明信息。
int k=0;
System.out.println(10/k);
解决方案：在执行除法计算之前，进行分母是否为0的判断

2、ArrayIndexOutOfBoundsException数组下标越界，数组下标的取值范围为[0,length-1]
int[] arr=new int[5];
System.out.println(arr[5]);
解决方案：通过下标访问数组元素时，首先对数据下标进行范围判断

3、NullPointerException空指针异常，针对null对象调用方法
   Object obj=null;
   System.out.println(obj.toString());
解决方案：必须保证针对引用类型变量调用方法之前，变量不能为null；否则有可能
为空时，先进行null值判断，非空再调用方法
       String.valueOf(obj)

4、ClassCastException引用类型转换时异常，将变量强制转换为不兼容的类型
   Object obj = new Random();
   int year=((Date) obj).getYear()+1900;
解决方案：进行强制类型转换之前首先使用instanceof运算符进行类型兼容性的判断
   Object obj = new Random();
   if (obj instanceof Date) {
           int year = ((Date) obj).getYear() + 1900;
   }

5、NumberFormatException数据格式异常
   String str="123a";
   int kk=Integer.parseInt(str);
解决方案：进行数据类型转换之前，针对字符串内容进行格式判断，推荐使用正则式
   String str = "123a";
   boolean res = true;
   for (int i = 0; i < str.length(); i++) {
       char tmp = str.charAt(i);
       if (tmp > '9' || tmp < '0') {
           res = false;
           break;
       }
   }
   if (res) {
       int kk = Integer.parseInt(str);
       System.out.println(kk);
   }

异常的捕获和处理
   try{
       try代码段中包含可能产生异常的代码，有人称为陷阱代码，
       在执行过程中如果出现了异常，则异常之后的java语句不会
       执行。转而执行catch部分的代码
   } catch(SomeException e){ 可以写多个
       try后可以跟一个多个catch代码段，针对不同异常执行不同
       的处理逻辑。当异常发生时，程序会中止当前的流程，根据获
       取异常的类型去执行响应的代码段。注意异常类型判定时是从
       上向下逐个判断的。
   }finally{
       finally代码是无论是否发生异常都会执行的代码
   }

基本用法
   Integer kk=null;
   try{
   String str="123.456";
   //由于str参数数据不合法，不是整数，所以这里异常NumberFormatException
   kk=Integer.parseInt(str);
   System.out.println("数据转换结束");//上句出现异常，这里就不会执行
   } catch(Exception e){//出现异常后进行类型判断，如果是这种异常则执行这里的代码段
   System.out.println("出现了错误："+e.getMessage());
   e.printStackTrace(); //在控制台上打印输出调用栈
   }
   System.out.println("转换结果为："+kk);

int[] arr = new int[Integer.MAX_VALUE];

OOM：当JVM因为没有足够的内存来为对象分配空间并且垃圾回收器也已经没有空间可回收
时，就会抛出这个error OutOfMemoryError

   OOM产生的原因
   1、分配的少了：比如虚拟机本身可使用的内存（一般通过启动时的VM参数指定）太少
   2、应用用的太多，并且用完没释放，浪费了。此时就会造成内存泄露或者内存溢出。

    内存泄露：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时
    这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。

    内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。

   在Java语言中由于存在了垃圾自动回收机制，所以一般不用去主动释放不用的对象
   所占的内存，也就是理论上来说，是不会存在内存泄露的。但是，如果编码不当，
   比如将某个对象的引用放到了全局的Map中，虽然方法结束了，但是由于垃圾回收器
   会根据对象的引用情况来回收内存，导致该对象不能被及时的回收。如果该种情况
   出现次数多了，就会导致内存溢出，比如系统中经常使用的缓存机制。Java中的内存
   泄露，不同于C++中的忘了delete，往往是逻辑上的原因泄露。

最常见的OOM情况有以下三种：
   1、java.lang.OutOfMemoryError: Java heap space ------>java堆内存溢出，
   此种情况最常见，一般由于内存泄露或者堆的大小设置不当引起。对于内存泄露，需
   要通过内存监控软件查找程序中的泄露代码，而堆大小可以通过虚拟机参数-Xms,-Xmx
   等修改。
   2、java.lang.OutOfMemoryError: PermGen space ------>java永久代溢出，即
   方法区溢出了，一般出现于大量Class或者jsp页面，或者采用cglib等反射机制的情况
   ，因为上述情况会产生大量的Class信息存储于方法区。此种情况可以通过更改方法区
   的大小来解决，使用类似-XX:PermSize=64m -XX:MaxPermSize=256m的形式修改。另
   外，过多的常量尤其是字符串也会导致方法区溢出。
   3、java.lang.StackOverflowError ------> 不会抛OOM error，但也是比较常见
   的Java内存溢出。JAVA虚拟机栈溢出，一般是由于程序中存在死循环或者深度递归调用
   造成的，栈大小设置太小也会出现此种溢出。可以通过虚拟机参数-Xss来设置栈的大小。

throw 人为编码抛出异常
   - new RuntimeException()
   - new RuntimeException("异常的提示信息");

throws--用在方法签名中，用于声明该方法可能抛出的异常，要求谁调用谁处理这个异常。
主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出，就表示在主方法里面
可以不用强制性进行异常处理，如果出现了异常，就交给JVM进行默认处理，则此时会导致程
序中断执行。
   public void pp() throws Exception{}

try/catch结构的问题：一个try结构后面可以跟无数个catch结构
   try {
           ss = sc.nextLine();
           age = Integer.parseInt(ss);
   } catch (NumberFormatException e) {
   //异常类型的判定不是最佳匹配，而是逐一匹配，一旦匹配成功，则不会继续进行匹配
   //必须小在前大在后
           System.out.println(ss);
           System.out.println("数据格式错误!");
       } catch (Exception e) {
           System.out.println("其它问题!");
       }

   允许在catch中声明多个类型
       注意：多个异常类型不要出现父子异常，如果需要写父不写子即可
       BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       int age = -1;
       String ss = null;
       try {
           ss = br.readLine();
           age = Integer.parseInt(ss);
       } catch (NumberFormatException | IOException e) {
           System.out.println("其它问题!");
       }
       System.out.println(age);

强调：catch只匹配成功一次即可，注意不是最佳匹配

catch结构中的e是用于指代陷阱代码中的异常对象
- getMessage():String用于获取有关异常事件的信息,一般是异常信息的描述，
例如【For input string: "123.456"】

- toString():String，输出格式为【java.lang.NumberFormatException:
For input string: "123.456"】

- printStackTrace():void用来跟踪异常事件发生时执行堆栈的内容，注意：这
里的输出默认采用错误流System.err进行输出，如果还使用了System.out进行输
出，则不能保证显示顺序

捕获异常后允许初步处理后，继续向上抛出
try{
int k=0;
system.out.println(10/k);
} catch(ArithmeticException e){
System.out.println(e);
e=new ArithmeticException("就是不告诉你"); //注意按照Java变量的规则，这里的类型不能变，所以可以new当前类型，也可以子类型
throw e;
}catch(NullPointerException e){
System.out.println(e);
}

但是使用多异常时则不能修改e对象
try{
int k=0;
System.out.println(10/k);
}catch(ArithmeticException | NullPinterException e){ 要求异常类型之间不能有继承关系,如果有继承关系应该只写大异常类型即可
System.out.println(e);
e=new ArithmeticException("就是不告诉你"); //语法报错
throw e;
}

finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能够
对程序的状态作统一的管理
   无论try所指定的程序块是否抛出异常，finally所指定的代码都要执行。
   try可以没有catch而直接使用finally，当然在方法上声明抛出

   try{... }catch(Exception e){... } finally{...}

   public void pp()throws Exception{
       try{....} finally{...}
   }

   通常在finally语句中可以进行资源的清除工作，例如关闭打开的文件，删除临时文件等。
   注意Java的垃圾回收机制只能回收再堆内存中对象所占用的内存，而不会回收任何物理资源
   （如数据库连接、网络连接和磁盘文件等）

特殊情况导致finally执行出现问题
   - 在前边的代码中使用System.exit(int)退出应用
       System.exit(int status)这个方法是用来结束当前正在运行中的java虚拟机。
   - status是非零参数，那么表示是非正常退出。
       - System.exit(0)是正常退出程序，而System.exit(1)或者说非0表示非正常退出程序。
   - 程序所在的线程死亡或者cpu关闭
   - 如果在finally代码块中的操作又产生异常，则该finally代码块不能完全执行结束

考核点：finally块和return
   try{
       int k=100;
       return 100;
   } catch(Exception e){
       return 99;
   } finally{
       return 88;
   }

   最终执行的返回值是finally里面的88，不管是否出现异常

   不建议这种写法，因为具备二义性
   int res=-1;
   try{
       ....
       res=100;
   } catch(Exception e){
       ...
       res=98;
   } finally{
       ...
       res=88;
   }
   return res;

自动关闭的写法
   依赖finally执行资源回收操作
   public class Test2 {
       public static void main(String[] args) {
           Reader r = null;
           try {
               r = new FileReader("d:/aaa.txt");
               int temp = -1;
               while ((temp = r.read()) != -1) {
                   System.out.print((char) temp);
               }
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               try {
                   if (r != null)
                       r.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }

   JDK1.7引入简化写法
   public class Test3 {
       public static void main(String[] args) throws Exception {
           try (Reader r = new FileReader("d:/aaa.txt");) {
               int temp = -1;
               while ((temp = r.read()) != -1) {
                   System.out.print((char) temp);
               }
           }
       }
   }
   这里引入了Closeable和AutoCloseable接口，可以自动关闭资源。不需要使用finally编程关闭

容易出现的一个编码问题：隐藏异常
   try{
       陷阱代码;
   } catch(Exception e){
       空实现;
   }

最佳异常相关编程实践
1、不要在fianlly中使用return
2、不要在finally中抛出异常。
3、减轻finally的任务，不要在finally中做一些其它的事情，finally块仅仅用来释放资源是最合适的。
4、将尽量将所有的return写在函数的最后面，而不是try … catch … finally中
5、不要过度使用异常，不要把异常当做不同的逻辑分支对待
6、不要使用过于庞大的try块
7、避免使用catch all语句 try{}catch(Throwable t){}
8、坚决不要忽略捕获的异，坚决不允许catch块中内容为空

自定义异常
public class AccountException extends Exception {
   public AccountException() {
       super("账户余额不足!");
   }

需要编写的程序：

- 一个无参构造函数

其余的方法可以使用IDE工具自动生成

- 一个带有String参数的构造函数，并传递给父类的构造函数。
- 一个带有String参数和Throwable参数，并都传递给父类构造函数
- 一个带有Throwable 参数的构造函数，并传递给父类的构造函数。

2、在方法适当的位置生成自定义异常的实例，并使用throw语句抛出
public void zhuan(Account source, Account target, long mount) throws AccountException {//告知调用方，这个方法可能会出现这个问题，要求调用方法进行处理
   // 因为定义AccountException的父类为Exception，所以这个异常属于受检型异常，所以必须进行处理，try/catch或者throws
   if (source.getBalance() < mount)
       throw new AccountException();
   ... ...
}

3、在方法的声明部分用throws语句声明该方法可能会抛出的异常或者使用try/catch结构直接
进行处理或者自定义异常为运行时异常
- 使用运行时异常是可以简化调用方编程，但是也可能导致调用方根本不知道这里可能会出现异常