2. 程式人生 > >《Java 解惑》 第五章 異常之謎

《Java 解惑》 第五章 異常之謎

阿新 • • 發佈：2018-10-31

簡述：

《Java 解惑》 第五章 異常之謎 - 筆記


內容：

謎題36： try中的return不會影響finally中方法執行

package 異常之謎.優柔寡斷;

public class Indecisive {
    public static void main(String[] args){
        System.out.println(decision());
    }

    static boolean decision() {
        try{
            return true;
        } finally {
            return false;
        }
    }
}

結果輸出了false ,


原因：

無論try語句塊是正常結束的，還是意外結束的，在一個try-finally語句中，finally語句塊總是在控制權離開try語句塊時執行

警告：不要使用return、break、continue或throw來退出finally語句塊，並且不要讓受檢查的異常傳播到finally語句之外



謎題37：受檢查的異常不能隨意捕獲

1）


說明： try語句中沒有宣告會丟擲任何受檢查異常，而在catch字句中要捕獲一個型別為E的受檢查異常

這就是一個編譯期錯誤


2）

package 異常之謎.極端不可思議;

public class Arcane2 {
    public static void main(String[] args) {
        try {
            // do nothing
        } catch (Exception e) {
            System.out.println("exception!!");
        }
    }
}

說明：捕獲Exception或Throwable的catch子句是合法的，不管其相對應的try字句的內容為何


3）

Type1.java

public interface Type1 {
    void f() throws CloneNotSupportedException;
}

Type2.java 

public interface Type2 {
    void f() throws InterruptedException;
}

Type3.java 

public interface Type3 extends Type1, Type2 {
}

Arcane3.java 

public class Arcane3 implements Type3 {

    public void f() {
        System.out.println("Hello World ");
    }
    
    public static void main(String[] args) {
        Type3 t3 = new Arcane3();
        t3.f();
    }
}


說明：一個方法可以丟擲的受檢查異常集合是它所適用的所有型別宣告要丟擲的受檢查異常集合的 交集。


謎題38：final 欄位只有在的確未賦過值的地方才能被賦值



解釋：
Java編譯器規定，final欄位只有在他的確未賦過值的地方才可以被賦值，而本例中try方法中可能會對USER_ID作賦值 編譯器謹慎起見組織了catch中的賦值
解決方式，重構靜態語句塊中程式碼為一個輔助方法 
package 異常之謎.不受歡迎的賓客;

public class UnwelcomeGuest {
    public static final long GUEST_USER_ID = -1;
    
    private static final long USER_ID = getUserIdOrGuest();
    
    private static long getUserIdOrGuest(){
        try {
            return getUserIdFromEnvironment();
        } catch (IdUnavailableException e) {
            System.out.println("Logging in as guest");
            return GUEST_USER_ID;
        }
    }
    
    private static long getUserIdFromEnvironment()
        throws IdUnavailableException {
        throw new IdUnavailableException();
    }
    
    public static void main(String[] args){
        System.out.println("User ID: " + USER_ID);
    }
}

class IdUnavailableException extends Exception {
    IdUnavailableException(){}
}




謎題39：System.exit 的中斷

package 異常之謎.您好_再見;

public class HelloGoodbye {
    public static void main(String[] args) {
        try {
            System.out.println("Hello World");
            System.exit(0);
        } finally {
            System.out.println("Goodbye World!");
        }
    }
}

解釋： 當呼叫System.exit時， 虛擬機器（VM）在關閉前要執行兩項清理工作。首先它執行所有的關閉掛鉤操作，這些掛鉤已經註冊到Runtime.addShutdownHook上。這對釋放VM之外的資源很有幫助。 務必要為那些必須在VM退出之前發生的行為關閉掛鉤。 
package 異常之謎.您好_再見;

public class HelloGoodbye {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        Runtime.getRuntime().addShutdownHook(
            new Thread() {
                @Override
                public void run() {
                    System.out.println("Goodbye World!");
                }
            });
        System.exit(0); //停止所有程式縣城，在停止VM之前會執行關閉掛鉤操作
    }
}
輸出：



謎題40：構造器丟擲的異常

package 異常之謎.不情願的構造器;

public class Reluctant {
    private Reluctant internalInstance = new Reluctant();
    
    public Reluctant() throws Exception {
        throw new Exception("I'm not coming out");
    }
    
    public static void main(String[] args){
        try {
            Reluctant b = new Reluctant();
            System.out.println("Surprise!");
        } catch (Exception ex){
            System.out.println("I told you so");
        }
    }
}

輸出：



說明：
本程式包含了一個無線遞迴。當你呼叫一個構造器時，例項變數的初始化操作將先於構造器的程式體而執行。 例項變數的初始化操作將先於構造器的程式體而執行，本例中，internalInstance變數的初始化操作遞迴呼叫 了構造器，而該構造器通過再次呼叫Reluctant構造器而初始化該變數自己的internalInstance欄位，而無限遞迴下去


謎題41：finally中關閉流也要考慮異常

package 異常之謎.欄位和流;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {
    static void copy(String src, String dest) throws IOException {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream(src);
            out = new FileOutputStream(dest);
            byte[] buf = new byte[2014];
            int n;
            while ((n = in.read(buf)) >= 0){
                out.write(buf, 0, n);
            }
        } finally {
            if (in != null)
                in.close();
            if(out != null)
                out.close();
        }
    }
    
    public static void main(String[] args) throws IOException {
        String src = "in.txt";
        String dest = "dest.txt";
        copy(src, dest);
    }
}

說明： finally中的close方法也可能跑出IOException異常，如果這個正好發生在in.close被呼叫的時候，那麼就會阻止out.close被呼叫

修改方式， 自定義finally中關閉的方法，從5.0開始，stream中都實現了closeable介面 
package 異常之謎.欄位和流;

import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {
    static void copy(String src, String dest) throws IOException {
        InputStream in = null;
        OutputStream out = null;
        try {
            in = new FileInputStream(src);
            out = new FileOutputStream(dest);
            byte[] buf = new byte[2014];
            int n;
            while ((n = in.read(buf)) >= 0){
                out.write(buf, 0, n);
            }
        } finally {
            closeIgnoringException(in);
            closeIgnoringException(out);
        }
    }
    
    public static void main(String[] args) throws IOException {
        String src = "in.txt";
        String dest = "dest.txt";
        copy(src, dest);
    }
    
    private static void closeIgnoringException(Closeable c){
        if(c != null){
            try {
                c.close();
            } catch(IOException ex){
                // do if it fails
            }
        }
    }
}



謎題42：不要用異常終止迴圈


package 異常之謎.異常為迴圈而拋;

public class Loop {
    private static boolean thirdElementIsThree(int[] a) {
        return a.length>=3 && a[2]==3;
    }
    
    public static void main(String[] args) {
        int[][] tests = {
            {6,5,4,3,2,1}, {1,2}, {1,2,3}, {1,2,3,4}, {1}               
        };
        
        int successCount = 0;
        
        try {
            int i = 0;
            while(true){
                if(thirdElementIsThree(tests[i++]))
                    successCount ++;
            }
        } catch(ArrayIndexOutOfBoundsException e) {
            // No more tests to process
        }
        System.out.println(successCount);
    }
}


說明： 不要使用異常控制迴圈，應該只為異常條件而使用異常 修改為： 
package 異常之謎.異常為迴圈而拋;

public class Loop {
    private static boolean thirdElementIsThree(int[] a) {
        return a.length>=3 && a[2]==3;
    }
    
    public static void main(String[] args) {
        int[][] tests = {
            {6,5,4,3,2,1}, {1,2}, {1,2,3}, {1,2,3,4}, {1}               
        };
        
        int successCount = 0;
        
        for (int[] test : tests) {
            if(thirdElementIsThree(test))
                successCount++;
        }
        
        
        System.out.println(successCount);
    }
}




謎題43：實現throw語句要做的事情，但是它繞過了編譯器所有異常檢查操作

package 異常之謎.異常地危險;

public class Test {
    public static void sneakyThrow(Throwable t){
        Thread.currentThread().stop();
    }
    
    public static void main(String[] args) {
        sneakyThrow(new Exception("超級異常"));
        System.out.println("execute after throw!");
    }
}

執行結束後，控制檯沒有輸出什麼東西，看來是被異常終止了 下面用Class.newInstance方法 該方法將傳播從空的構造器所丟擲的任何異常，包括受檢查的異常，使用這個方法，可以有效地繞開在其他情況下都會執行的編譯器異常檢查 
package 異常之謎.異常地危險;

public class Thrower {
    private static Throwable t;
    
    private Thrower() throws Throwable {
        throw t;
    }
    
    public static synchronized void sneakyThrow(Throwable t){
        Thrower.t = t;
        try {
            Thrower.class.newInstance();
        } catch (InstantiationException e) {
            throw new IllegalArgumentException();
        } catch (IllegalAccessException e) {
            throw new IllegalArgumentException();
        } finally {
            Thrower.t = null;  // Avoid Memory Leak
        }
    }
}


備註：finally語句塊中賦值為空，是防止記憶體洩露 解釋：Class.newInstance的文件描述，Constructor。newInstance方法通過將構造器丟擲的任何異常都包裝在一個（受檢查的）InvocationTargetException異常中而避免了這個問題


謎題44：刪除類

Strange1.java 
package 異常之謎.刪除類;

public class Strange1 {
    public static void main(String[] args) {
        try {
            Missing m = new Missing();
        } catch (java.lang.NoClassDefFoundError ex) {
            System.out.println("Got it!");
        }
    }
}

Strange2.java 
package 異常之謎.刪除類;

public class Strange2 {
    public static void main(String[] args) {
        Missing m;
        try {
            m = new Missing();
        } catch (java.lang.NoClassDefFoundError ex) {
            System.out.println("Got it!");
        }
    }
}

Missing.java 
package 異常之謎.刪除類;

public class Missing {
    Missing() {}
}

測試： 執行Strange1和Strange2之前刪除Missing.class 檔案，就會發現這兩個程式的行為有所不同。 其中一個跑出了一個未被捕獲的NoClassDefFoundError異常，而另一個卻列印了Got it!
Strange1 執行結果：


Strange2 執行結果：




編寫一個能夠探測類丟失的程式，用反射來實現 
package 異常之謎.刪除類;

public class Strange {
    public static void main(String[] args) throws Exception {
        try {
            Object m = Class.forName("Missing").newInstance();
        } catch (ClassNotFoundException ex ) {
            System.out.println("Missing.class lost !");
        }
    }
}




謎題45：無限函式遞迴


package 異常之謎.令人疲憊不堪的測驗;

public class Workout {
    public static void main(String[] args) {
        workHard();
        System.out.println("It's nap time.");
    }
    
    private static void workHard() {
        try {
            workHard();
        } finally {
            workHard();
        }
    }
}













相關推薦

《Java 解惑》 第五章 異常之謎

簡述： 《Java 解惑》 第五章 異常之謎 - 筆記 內容： 謎題36： try中的return不會影響finally中方法執行 package 異常之謎.優柔寡斷; public class Indecisive { public static vo

《Java 解惑》 第二章 表示式之謎

簡述： 《Java 解惑》  第二章 表示式之謎 謎題1：奇數性 package com.anialy.test.java_puzzlers.chapter_1; public class 奇數性 { public static void mai

使用Java實現面向對象編程——第五章 異常

leg 編譯錯誤 bubuko 錯誤信息 執行 tcl tin 例如 nal 1、 嘗試通過if-else來解決異常問題： Eg： public class Test2 { public static void main(String[] args)

《Effective Java》第9章 異常

電話 參考資料 輸入 取消 技術 線程停止 調用 個數 表示 第58條:對可恢復的情況使用受檢異常，對編程錯誤使用運行時異常 Java程序設計語言提供了三種可拋出結構(throwable) ;受檢的異常(checked exception)運行時異常(run-time e

JAVA基礎第五章-集合框架Map篇 JAVA基礎第一章-初識java JAVA基礎第二章-java三大特性：封裝、繼承、多型 JAVA基礎第三章-類與物件、抽象類、介面 JAVA基礎第四章-集合框架Collection篇

 業內經常說的一句話是不要重複造輪子，但是有時候，只有自己造一個輪子了，才會深刻明白什麼樣的輪子適合山路，什麼樣的輪子適合平地！ 我將會持續更新java基礎知識，歡迎關注。   往期章節： JAVA基礎第一章-初識java

第五章 SpringMVC之ViewResolver和View解析

          過完年了，本來是想在年前將SpringMVC系列寫完的，只是在接近年末的時候沒有了一種學習心態，這兩天看了一下ViewResolver原始碼，就想盡快將這篇部落格寫出，也好完結SpringMVC的系列部落格並開始下面的學習。           自己寫的

《Java從小白到大牛》之第14章 異常處理（上）

《Java從小白到大牛》紙質版已經上架了！！！ 很多事件並非總是按照人們自己設計意願順利發展的，而是有能夠出現這樣那樣的異常情況。例如：你計劃週末郊遊，你的計劃會安排滿滿的，你計劃可能是這樣的：從家裡出發→到達目的→游泳→燒烤→回家。但天有不測風雲，當前你準備

《Java從小白到大牛》之第14章 異常處理（下）

《Java從小白到大牛》紙質版已經上架了！！！ 釋放資源 有時在try-catch語句中會佔用一些非Java資源，如：開啟檔案、網路連線、開啟資料庫連線和使用資料結果集等，這些資源並非Java資源，不能通過JVM的垃圾收集器回收，需要程式設計師釋放。為了確保這

學習筆記之《Java核心技術卷I》---- 第七章 異常、斷言和日誌

異常物件都是派生與Throwable的一個例項 派生於Error類或RuntimeException類的所有異常稱為非受查異常，所有其他異常稱為受查異常 一個方法必須宣告所有可能丟擲的受查異常，而非受查異常要麼不可控制，要麼就應該避免發生 關鍵字throws位於方法之

學習筆記之《Java核心技術卷I》---- 第五章 繼承

Java中所有繼承都是公有繼承 this是當前物件的引用，而super不是一個物件的引用，不能將super賦給另一個物件變數，它只是一個指示編譯器呼叫超類方法的特殊關鍵字 /* 以下程式碼可以成功編譯執行 */ class Employee{ private String na

Java學習之路 第五章 面向物件（1）

面向物件（1） 1、認識物件 （1）萬物皆物件。 （2）物件=特點或特徵（屬性）+行為或（方法）。 （3）物件由屬性和方法組成，一定要具體到個體上。 2、認識類 （1）類是一些具有共同屬性和方法的物件的一個抽象。 （2）類是一個概念，不是具體的一個物件。 （3）

構建之法 第五章 團隊和流程

ini 之前 組織 第五章 團隊 mod 交互 然而 逆轉 典型的團隊開發模式和流程，完全是新的內容；涉及到更多的術語和有意思的策略性東西 1.團隊模式【我比較認可的】 主治醫師模式 由首席程序員（相當於首席醫生）負責整個工程，周圍人員各司其職，配合支持中心人物的工作；

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

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

讀《構建之法》第五章

交付 瀑布模型 pro 集體 成員 統一 工作 變形 流程 第五章說的是團隊和流程， 什麽是團隊？ 團隊有一致的集體目標，團隊要一起完成這目標，一個團隊的成員不一定要同時工作，例如接力賽跑。 團隊成員有各自的分工，互相依賴合作，共同完成任務。 軟件團隊有許多

《構建之法》第五章讀書筆記

收集數據 效率 衡量 配置 測試 人在 模式 輸出 發現 第5章 團隊和流程　 一、非團隊和團隊 團隊的共同特點： 1、團隊有一致的集體目標，團隊要一起完成這目標。一個團隊的成員不一定要同時工作，例如接力跑。 2、團隊成員有各自的分工，互相依賴合作，共同完成任務。 二、軟件

讀構建之法 第五章：團隊和流程

min 這樣的 程序員 希望 成員 eat 貢獻 核心 不能 團隊有一致的集體目標，團隊要一起完成這目標。一個團隊的成員不一定要同時工作，例如接力賽跑。 團隊成員有各自的分工，互相依賴合作，共同完成任務。 軟件團隊有各種形式，適用於不同的人員和需求。基於直覺形成的團隊模式未

《Java並發編程實戰》第五章 同步容器類 讀書筆記

blank sortedset 方法 width lists 讀書 run 生產者消費者模式 ear 一、同步容器類 1. 同步容器類的問題 線程容器類都是線程安全的。可是當在其上進行符合操作則須要而外加鎖保護其安全性。 常見符合操作包括： . 叠代 . 跳轉(

Java（第四章和第五章）

簡潔 重復 清晰 快速 結束 編寫 int() input 出現 第四章 一、 switch結構（開關語句）的語法 switch(表達式[dream1] ){ case 常量1[dream2] : //語句塊1

構建之法第五章讀書心得

多個 功能需求 優先級 周期 基礎 第五章 高效 包括 交付 這一章我們主要學習了團隊和流程。團隊簡而言之就是開發一個軟件工程的團隊，那麽團隊究竟怎樣在一起開發這一軟件便有了多種多樣的方法。 比如所有人都一起做的一窩蜂模式，但這樣模式弊端很大，雖然都做了許多工作，但結合起來

Java入門 第一季第五章 編程練習解析

使用 接收 family 程序 基本 快捷 ng- 導入 ear 這是我學習慕課網Java課程的筆記。原視頻鏈接為：http://www.imooc.com/learn/85 5-1 基本寫法 自己主動補全快捷鍵：alt + /