《Think in Java》閱讀筆記·第三卷

阿新 • • 發佈：2019-01-08

通過異常處理錯誤

異常情形：是指阻止當前方法或作用域繼續執行的問題。

監控區域：一段可能產生異常的程式碼區域，即try區域。

異常處理程式：處理異常的地點，即catch區域。

異常處理的兩種模型

終止模型：一旦丟擲異常，將無法返回產生異常處。

恢復模型：在產生異常時不丟擲異常，而是通過方法或者將try放到迴圈語句中以修補異常。

注意：恢復模型容易增強程式耦合性

自定義異常

import java.util.logging.Logger;

public class MyException {
    private static void f() throws CustomException{
        System.out 
.println("f:");
        throw new CustomException();
    }
    private static void g(String msg)throws  CustomException{
        System.out.println("g:");
        throw new CustomException(msg);
    }
    private static void h(){
        int x,y,z;
        x=4;
        y=0;
        try {
            z=x/y;
        } catch 
 (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String... args) {
        try {
            f();
        } catch (CustomException e) {

            e.printStackTrace(System.out);
        }
        try {
            g("msg");
        } catch (CustomException e) {
            e.printStackTrace(System.out 
);
        }
        h();
    }
}
class CustomException extends Exception{
    private Logger logger=Logger.getLogger("CustomException");
    public CustomException(){
    }
    public CustomException(String msg){
        super(msg);
    }

    @Override
    public String getMessage() {
        //return super.getMessage();
        return "This is my custom error info";
    }
}

當註釋掉return super.getMessage()：

f:
thinkinjava.CustomException: This is my custom error info
at thinkinjava.MyException.f(MyException.java:7)
at thinkinjava.MyException.main(MyException.java:26)
g:
thinkinjava.CustomException: This is my custom error info
at thinkinjava.MyException.g(MyException.java:11)
at thinkinjava.MyException.main(MyException.java:32)
h:
java.lang.ArithmeticException: / by zero
at thinkinjava.MyException.h(MyException.java:19)
at thinkinjava.MyException.main(MyException.java:36)

當註釋掉return “This is my custom error info”：

f:
thinkinjava.CustomException
at thinkinjava.MyException.f(MyException.java:7)
at thinkinjava.MyException.main(MyException.java:26)
g:
thinkinjava.CustomException: msg
at thinkinjava.MyException.g(MyException.java:11)
at thinkinjava.MyException.main(MyException.java:32)
h:
java.lang.ArithmeticException: / by zero
at thinkinjava.MyException.h(MyException.java:19)
at thinkinjava.MyException.main(MyException.java:36)

getMessage類似於toString方法

異常與記錄日誌

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.Logger;

public class LoggerException {
    private static  Logger logger=Logger.getLogger("LoggerException");
    private static void logprint(Exception e){
        StringWriter sw=new StringWriter();
        PrintWriter pw=new PrintWriter(sw);
        e.printStackTrace(pw);
        logger.severe(pw.toString());
    }
    public static void main(String...args){
        try {
            throw new NullPointerException();
        } catch (NullPointerException e) {
            logprint(e);
        }
    }
}

五月 01, 2018 9:31:36 下午 thinkinjava.LoggerException logprint
嚴重: [email protected]

throw：拋錯誤給上一層處理

public class Thrower {
    static void demoproc() {
        try {
            throw new NullPointerException("demo");
        } catch(NullPointerException e) {
            System.out.println("Caught inside demoproc.");
            throw e;
        }
    }
    public static void main(String args[]) {
        try {
            demoproc();
        } catch(NullPointerException e) {
            System.out.println("Recaught: " + e);
        }
    }
}

Caught inside demoproc.
Recaught: java.lang.NullPointerException: demo

棧軌跡

public class StackTracer {
    private static void a(){
        try{
            throw new Exception();
        }catch (Exception e){
            for(StackTraceElement stackTraceElement:e.getStackTrace())
                System.out.println(stackTraceElement.getMethodName());
        }
    }
    private static void b(){
       a();
    }
    private static void c(){
        b();
    }
    public static void main(String...args){
        a();
        System.out.println("-------------");
        b();
        System.out.println("-------------");
        c();

    }
}

輸出：

a
main
-------------
a
b
main
-------------
a
b
c
main

從棧底開始呼叫，類似於遞迴

若把當前異常重新丟擲，printStackTrace()顯示的仍然是原來異常丟擲點的呼叫棧資訊

    private static void  d() throws Exception{
        throw new Exception("throw new Exception from d");
    }

    private static void e() throws Exception{
        try{
            d();
        }catch (Exception e){
            System.out.println("e try catch");
            e.printStackTrace(System.out);
            throw e;
        }
    }

    private static void f() throws Exception{
        try{
            d();
        }catch (Exception e){
            System.out.println("f try catch");
            e.printStackTrace(System.out);
            throw (Exception) e.fillInStackTrace();
        }
    }
    public static void main(String...args){
        try {
            e();
        }catch (Exception e){
            System.out.println("main try catch from e");
            e.printStackTrace(System.out);
        }
        try {
            f();
        }catch (Exception e){
            System.out.println("main try catch from f");
            e.printStackTrace(System.out);
        }
    }

e try catch
java.lang.Exception: throw new Exception from d
at thinkinjava.StackTracer.d(StackTracer.java:19)
at thinkinjava.StackTracer.e(StackTracer.java:24)
at thinkinjava.StackTracer.main(StackTracer.java:44)
main try catch from e
java.lang.Exception: throw new Exception from d
at thinkinjava.StackTracer.d(StackTracer.java:19)
at thinkinjava.StackTracer.e(StackTracer.java:24)
at thinkinjava.StackTracer.main(StackTracer.java:44)
f try catch
java.lang.Exception: throw new Exception from d
at thinkinjava.StackTracer.d(StackTracer.java:19)
at thinkinjava.StackTracer.f(StackTracer.java:34)
at thinkinjava.StackTracer.main(StackTracer.java:51)
*main try catch from f
java.lang.Exception: throw new Exception from d
at thinkinjava.StackTracer.f(StackTracer.java:38)
at thinkinjava.StackTracer.main(StackTracer.java:51)

如最後一個輸出結果，其已經不再輸出原來的那個丟擲點了d了

若丟擲的是兩個不同的自定義異常，那麼就無法關聯，即第二次丟擲點打印出的棧軌跡不會有第一次的任何資訊，這是如果我們也要列印第一次丟擲點的棧軌跡，則需要用到異常鏈：

public class ExceptionLink {
    class MyException2 extends Exception{
        public MyException2(Throwable throwable){
            super(throwable);
        }
        public MyException2(){
            super();
        }
    }
    class MyException1 extends Exception{
        public  MyException1(){
            super();
        }
    }
    private void a() throws MyException1{
        throw new MyException1();
    }
    private  void b() throws MyException2{
        try {
            a();
        }catch (MyException1 exception1){
            System.out.println("b try catch");
            exception1.printStackTrace(System.out);
            throw new MyException2();
            //throw new MyException2(exception1);
        }
    }
    public static void main(String...args){
        ExceptionLink exceptionLink=new ExceptionLink();
        try {
            exceptionLink.b();
        } catch (MyException2 myException2) {
            System.out.println("main try catch");
            myException2.printStackTrace(System.out);
        }
    }
}

輸出：

b try catch
thinkinjava.ExceptionLink$MyException1
    at thinkinjava.ExceptionLink.a(ExceptionLink.java:18)
    at thinkinjava.ExceptionLink.b(ExceptionLink.java:22)
    at thinkinjava.ExceptionLink.main(ExceptionLink.java:32)
main try catch
thinkinjava.ExceptionLink$MyException2
    at thinkinjava.ExceptionLink.b(ExceptionLink.java:26)
    at thinkinjava.ExceptionLink.main(ExceptionLink.java:32)

如上在第二個丟擲點並沒有丟擲第一個丟擲點所丟擲的資訊，因為這是兩個不同異常類
若將註釋掉的那行取消掉註釋則會輸出：

b try catch
thinkinjava.ExceptionLink$MyException1
    at thinkinjava.ExceptionLink.a(ExceptionLink.java:18)
    at thinkinjava.ExceptionLink.b(ExceptionLink.java:22)
    at thinkinjava.ExceptionLink.main(ExceptionLink.java:32)
main try catch
thinkinjava.ExceptionLink$MyException2: thinkinjava.ExceptionLink$MyException1
    at thinkinjava.ExceptionLink.b(ExceptionLink.java:26)
    at thinkinjava.ExceptionLink.main(ExceptionLink.java:32)
Caused by: thinkinjava.ExceptionLink$MyException1
    at thinkinjava.ExceptionLink.a(ExceptionLink.java:18)
    at thinkinjava.ExceptionLink.b(ExceptionLink.java:22)
    ... 1 more

這便是異常鏈

finally語句在return語句中使用

try{
    return;
}finally{
    System.out.println("before return")
}

其會在返回前輸出”before return”

異常丟失

造成異常丟失的兩種情況：

try{
    throw new Exception1();
}finally{
    throw new Exception2();
}

try{
    throw new MyException();
}finally{
    return;
}

異常的限制

基類中的構造器和方法都聲明瞭丟擲異常，但在方法體內都沒丟擲異常，目的是讓其派生類在重寫該方法時強制捕獲該異常。
當一個基類和一個介面中都定義了相同的一個方法，但聲明瞭丟擲不同的異常。那麼在繼承了該基類和實現了該介面中的類中實現該方法，就不能丟擲在該類和該介面中該方法中宣告的任何異常，派生類可以不丟擲異常。
2中的情況無法限制構造器，因為在例項化派生類時會自動例項化基類構造器，所以派生類需要宣告基類構造器宣告的丟擲的異常。但是派生類構造器無法捕獲基類構造器的異常，因為在派生類構造器中super(…)必須處於最前端。
如下程式碼4，會編譯出錯，因為子類繼承了父類，然後覆蓋了父類的fun方法，但丟擲了父類方法沒有丟擲的異常。倘若編譯期沒有檢查到錯誤，在執行階段如果呼叫basic.fun()不用捕獲異常，但若Basic basic=new Child();basic.fun()就會需要捕獲異常。
如下程式碼5，c.fun()捕獲了MyException2的異常，而基類中的fun方法聲明瞭丟擲了MyException1異常，這是可行的，因為MyException2繼承於MyException1。

//4
public class Child extends Basic{
    //compile erro
    public void fun() throws MyException{}
}
class Basic{
    public void fun(){}
}

//5
public class MyException2 extends MyException1{}
public class Child extends Basic{
    public static final void main(String...args){
        Child c=new Child();
        try{
            c.fun();
        }catch(MyException2){}
    }
}
class Basic{
    public void fun() throws MyException1{}
}

異常匹配

catch(MyException)會捕獲MyException以及所有從它派生的異常

將被檢查異常轉換成不檢查異常

import java.io.IOException;

public class  TranstException{
    public TranstException(){

    }
    public static final void main(String...args){
        try{
            throwToOther(0);
        }catch(RuntimeException e){}//吞噬異常
        System.out.println("end");
    }
    private static void throwToOther(int i){
        try{
            switch(i){
                case 0:throw new IOException();
                case 1:throw new NullPointerException();
                case 2:throw new RuntimeException();
            }
            throw new IOException();
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

end

將每一個異常封裝成一個RuntimeException，然後通過getCause方法取出：

import java.io.IOException;

public class  TranstException{
    public TranstException(){

    }
    public static final void main(String...args){
        for(int i=0;i<3;i++){
            try{
                throwToOther(i);
            }catch (RuntimeException er){
                try{
                    throw er.getCause();
                }catch (IOException e){
                    System.out.println("IOException");
                }catch (NullPointerException e){
                    System.out.println("NullPointerException");
                }catch (RuntimeException e){
                    System.out.println("RuntimeException");
                } catch (Throwable throwable) {
                    System.out.println("Throwable");
                }
            }
        }
        System.out.println("end");
    }
    private static void throwToOther(int i){
        try{
            switch(i){
                case 0:throw new IOException();
                case 1:throw new NullPointerException();
                case 2:throw new RuntimeException();
            }
            throw new IOException();
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

IOException
NullPointerException
RuntimeException
end

《Think in Java》閱讀筆記·第三卷

通過異常處理錯誤異常情形：是指阻止當前方法或作用域繼續執行的問題。監控區域：一段可能產生異常的程式碼區域，即try區域。異常處理程式：處理異常的地點，即catch區域。異常處理的兩種模型終止模型：一旦丟擲異常，將無法返回產生異常處。恢

#Thinking in Java閱讀筆記# 第四章控制執行流程

迭代：while/do-while/for迴圈，在迭代語句的主體部分，可用break/continue控制迴圈的流程。 break：跳出迭代，且不執行餘下部分 continue：跳出當前迭代，執行下一次迴圈無限迴圈：while(true)/for(;;)

【Think in java讀書筆記】序列化

轉換 window 讀書筆記對象序列執行輕量 body 調用 Java的對象序列化將那些實現了Serializable接口的對象轉換成一個字節序列，並能夠在以後將這個字節序列完全恢復成為原來的對象。序列化機制能自動彌補不同操作系統之間的差異，也就是說在Window

Think In Java讀書筆記：內部類覆蓋及其初始化

圖片 10.10 clas 構造 col 向上轉型 pan center 類初始化　　本文相關章節：第十章內部類 10.10 內部類可以被覆蓋嗎　　在讀至本節第二個範例代碼時（及下方的代碼），我對輸出結果中的第一個“Egg.Yolk()”很不理解，為什麽它會第一個地方

think in java 讀書筆記

imp 優先級拼接別名現象乘除方法垃圾原則 java 第三章操作符 3.1 更簡單的打印語句原:System.out.println("打印"); 簡單:print("我是更簡單的"); =======需要導包 :import static net.mi

==和equalse的區別　——Thinking in Java學習筆記（三）

不知道是不是很多人和我一樣，一直都以為==比較的是引用物件的地址，equals比較的是物件的值？先來做個實驗： Test5 test3 = new Test5("spot", "Ruff!"); Test5 test4 = new Test5("spot", "Ruff!"); Sys

Think in Java反芻筆記(6)---HashMap的工作原理-hashcode和equals原理的再次深入

前言首先再次強調hashcode （==）和equals的真正含義（我記得以前有人會說，equals是判斷物件內容，hashcode是判斷是否相等之類）： equals：是否同一個物件例項。注意，是“例項”。比如String s = new String("test");

Think in Java反芻筆記(5)---介面之策略設計模式

在Think in Java 的第九章介面中在9.3（完全解耦）節中看到一個程式碼，貼出來如下： import java.util.*;

《Java程式設計思想》《Think in Java》筆記

前言這本書不適合初學者，這本書適合已經學過Java框架並做過一兩個專案的同學來看，這本書對基礎知識的理解非常透徹。我在看的時候常常有一種醍醐灌頂的感覺，常常為“原來是這樣子的！”而激動，確實是一本非常好的書。我在看書時將書本我覺得重點的內容原封不動的摘錄下來，給想看重點的

Think In Java 學習筆記

1. 判斷什麼時候該用繼承，什麼時候該用組合？如果想利用新類內部一個現有類的特性，而不想使用它的介面，通常應選擇合成。為判斷自己到底應該選用合成還是繼承，一個最簡單的辦法就是考慮是否需要從新類上溯造型回基礎類。若必須上溯，就需要繼承。但如果不需要上溯造型，就應提醒自己防

《影象處理、分析與機器視覺》（第4版）閱讀筆記——第三章影象及其數學與物理背景

3.1 概述 3.1.1 線性向量（線性）空間（vector（linear） space） 3.1.2 狄拉克（Dirac）分佈和卷積理想的衝擊是一個重要的輸入訊號，影象平面上的理想衝擊是用狄拉克分佈（Dirac distribution）定義的，。相當於訊號處理中的單位階躍函式

effective java-讀書筆記-第三章對於所有物件都通用的方法

第三章對於所有物件都通用的方法所有非final方法（equals、hashCode、toString、clone、finalize）都有明確的通用約定，因為它們被設計成是要被覆蓋的，如果不遵守，基於雜湊的集合（HashMap、HashSet、HashTable）可

Thinking in Java閱讀筆記（一）

第一章：物件導論抽象化的過程組合語言僅對底層的實體機器進行少量抽象化。許多所謂命令式程式語言（Fortran、BASIC、C），則在組合語言之上再抽象化。此類語言大幅改進了組合語言，但他們所做的主要是機器本身的抽象化，你依舊無法逃脫“以電腦結構進行問思考”的命運，因而

Effective Java讀書筆記 -- 第三章：對於所有物件都通用的方法

儘管Object是一個具體類，但是設計Object類主要是為了擴充套件。它的所有非final方法（equals、hashCode、toString、clone和finalize）都有明確的通用約定，因為它們就是被設計成要被覆蓋的。第八條：覆蓋equals時請遵守通用約定

《Think in Java》閱讀筆記·第二卷

內部類從外部類的非靜態方法之外的任意位置建立某個內部類的物件，都需要以外部類.內部類的格式指明物件型別內部類擁有外圍類的所有元素的訪問權外圍類物件建立一個內部類物件時，此內部類物件會祕密地捕獲一個指向那個外圍類物件的引用。在外圍類靜態方法中建

《Think In Java》閱讀筆記 ·第一卷

過載基本型別的過載當傳入較小精確度的數值時，會呼叫擁有最接近該精確度形參的方法。當傳入較大精確度的數值時，需要至少窄化轉換成所有過載方法中最大精確度的數值，否則編譯器將報錯。不能通過方法的返回值來區分過載方法構造器的過載在構造器中可以呼叫

think in java第十五章關於網路程式設計的讀書筆記

對於java的網路程式設計書中討論的全部歸納起來有Socket的使用，DatagramSocket的使用，java與CGI的配合使用，java連線資料庫以及java中呼叫遠端方法。首先是Socket的使用，對於服務端來說，應該宣告的是ServerSo

Java 線程第三版第五章極簡同步技巧讀書筆記

prev ear ont java else 停止第三版不同的結合一、能避免同步嗎？取得鎖會由於下面原因導致成本非常高：取得由競爭的鎖須要在虛擬機的層面上執行很多其它的程序代碼。要取得有競爭鎖的線程總是必須等到鎖被釋放後。 1. 寄

java並發編程的藝術，讀書筆記第三章

java並發編程的藝術final域的內存語義寫final域的重排規則：禁止把final域的寫重排序到構造方法之外，主要包括倆個個方面1）JMM禁止編譯器把final域的寫重排序到構造方法之外2）編譯器會在final域寫之後，構造函數return之前插入一個storestore屏障，這個屏障禁止處理器把fina

《Java編程思想》筆記第三章操作符

別名成了有一個 detail 無符號基本數據 bool lse 分享圖片 1.操作符種類：運算順序1-7 1.1 一元操作符（單目操作符） - 負號， + 正號，--遞減，++遞增 1.2 算術操作符 + - * / % 1.3 移位操作符 <<

《Think in Java》閱讀筆記·第三卷

通過異常處理錯誤

異常處理的兩種模型

自定義異常

異常與記錄日誌

棧軌跡

若把當前異常重新丟擲，printStackTrace()顯示的仍然是原來異常丟擲點的呼叫棧資訊

finally語句在return語句中使用

異常丟失

異常的限制

異常匹配

將被檢查異常轉換成不檢查異常

將每一個異常封裝成一個RuntimeException，然後通過getCause方法取出：

相關推薦