[Java] - Java核心技术卷I笔记 - 异常（十）

爱被打了一巴掌 2023-03-01 11:48 40阅读 0赞

# 异常 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE0OTYyNA_size_16_color_FFFFFF_t_70_pic_center]

`Error`描述了`Java`运行时系统内部错误和资源耗尽

## 捕获 ##

捕获处理错误

try{ 
        
    }
    catch(Exception e){ 
        e.getMessage()
    }
    catch(E1 | E2 e2){ }
    finally{ }

可以有多个`catch`；同一个`catch`语句可以捕获多个异常类型（一次一种），但不能为子类关系，同时异常对象为`final`；可以有`finally`，其最后执行

## 抛出 ##

*  找到合适异常类
 *  创建其对象
 *  `throw`对象

public void getFileStream throws IOException,...{ 
        EOFException e = new EOFException();
    	throw e;
        //或
        try{ }
        catch(...){ 
            throw new Exception();
        }
    }

## 异常再抛出 | 异常链 ##

捕获异常后对其处理或做其它动作后抛出，捕获中第二种在`catch`中抛出形式。

> 可以转换异常类型，添加日志行为后再抛出

**传递异常原因**

try{ 
        p1();
    }
    catch (IOException IOException){ 
        Exception e = new Exception("Other Exception");
        e.initCause(IOException.getCause());
        throw e;
    }

## 创建异常类 ##

继承`Exception`或其子类

class TestException extends Exception{ 
        public TestException(){ }
        //Throwable类有存储错误信息属性
        public TestException(String s){ 
            super(s);
        }
    }

## finally ##

无论是否有异常，都执行

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

> 若处理文件流，可以将流的关闭放在`finally`，但关闭语句也可能产生错误，因此需要嵌套`try`语句，显得混乱。而且若finally块也产生异常，只会报告最后那个异常，致使无法了解详细情况

### return ###

如果`try`与`finally`语句块中都有`return`语句，在`try`语句块中通过`return`返回时，依然会调用`finally`，而`finally`中的返回值会覆盖原来值

public class K { 
        public static void main(String[] args) { 
            System.out.println(p());
        }
        public static int p(){ 
            try { 
                int a = 5;
                return a*3;
            }catch (Exception e){ 
                System.out.println(e.getMessage());
            }
            finally{ 
                return 89;
            }
        }
    }

## try-with-source ##

在`try`块退出后自动关闭资源

> 传入对象需实现`AutoCloseable`接口

try(FileInputStream f = new FileInputStream(new File(""))){ 
    
    } catch (IOException e) { 
        e.printStackTrace();
    }

可以指定多个资源

try(FileInputStream in = new FileInputStream(new File("")); 
        FileOutputStream out = new FileOutputStream(new File(""))){ 
    
    } catch (IOException e) { 
        e.printStackTrace();
    }

也可以带`catch,finally`，但不推荐

关闭资源若产生异常，不会覆盖`try`块中异常

## Throwable ##

<table> 
 <thead> 
  <tr> 
   <th>返回类型</th> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Throwable</td> 
   <td>initCause(Throwable t)</td> 
   <td>设置错误原因</td> 
  </tr> 
  <tr> 
   <td>Throwable</td> 
   <td>getCause()</td> 
   <td>获取错误原因</td> 
  </tr> 
  <tr> 
   <td>StackTraceElement[]</td> 
   <td>getStackTraces()</td> 
   <td>获得构造这个对象时调用堆栈的信息</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>addSuppressed(Throwable t)</td> 
   <td>添加“抑制异常”</td> 
  </tr> 
  <tr> 
   <td>Throwable[]</td> 
   <td>getSuppressed()</td> 
   <td>获取“抑制异常”</td> 
  </tr> 
 </tbody> 
</table>

**示例**

package cc;
    
    import java.io.*;
    import java.nio.file.FileSystemNotFoundException;
    import java.util.Map;
    
    public class K { 
        public static void main(String[] args) { 
            try { 
                p1();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
        public static void p1() throws Exception { 
            try { 
                p2();
            }
            catch (Exception e){ 
                FileNotFoundException a1 = new FileNotFoundException();
                FileSystemNotFoundException a2 = new FileSystemNotFoundException();
                e.addSuppressed(a1);
                e.addSuppressed(a2);
                throw e;
            }
        }
        public static void p2() throws Exception { 
            throw new Exception();
        }
    }
    /* java.lang.Exception at cc.K.p2(K.java:28) at cc.K.p1(K.java:17) at cc.K.main(K.java:10) Suppressed: java.io.FileNotFoundException at cc.K.p1(K.java:20) ... 1 more Suppressed: java.nio.file.FileSystemNotFoundException at cc.K.p1(K.java:21) ... 1 more */

## Tip ##

*  尽可能详细描述异常
 *  合理地包含要捕获异常代码
 *  向高层次传递错误，而不是在基础方法中捕获错误

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE0OTYyNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20230208/7185e2b1634547ffb70637d8082ec7f9.png