Thinking in Java 第四版完整版第五章練習題初始化與清理

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

Thinking in Java 第四版完整版第五章練習題，記錄一下(jdk1.8.0)

/**
 * 練習1：建立一個類，它包含一個未初始化的String引用。驗證該引用被Java初始化成了null。
 * @author admin11
 * @date 2018年3月2日
 */

public class Exercise501 {

    String str;
    public static void main(String[] args) {
        System.out.println(new Exercise501().str);
    }
}

這裡寫圖片描述

/**
 * 練習2：建立一個類，它包含一個在定義時就被初始化了的String域，以及另一個通過構造器
 * 初始化的String域。這兩種方式有何差異？
 * @author admin11
 * @date 2018年3月2日
 */
public class Exercise502 {

    String str1 = "str1";
    String str2;
    public Exercise502(String str) {
        this.str2 = str;
    }

    // str1欄位在建構函式之前被初始化；從技術上講，str2欄位也是如此，在建立物件時設定成null。 

    // str2欄位可以選擇在呼叫建構函式時設定值。
    public static void main(String[] args) {
        Exercise502 e = new Exercise502("str");
        System.out.println("str1 = " + e.str1);
        System.out.println("str2 = " + e.str2);
    }
}

這裡寫圖片描述

/**
 * 練習3：建立一個帶預設構造器（即無參構造器）的類，在構造器中列印一條訊息。
 * 為這個類建立一個物件。
 * @author 
 admin11
 * @date 2018年3月5日
 */
public class Exercise503 {

    public Exercise503() {
        System.out.println("Default Construct");
    }

    public static void main(String[] args) {
        new Exercise503();
    }
}

這裡寫圖片描述

/**
 * 練習4：為前一個練習中的類新增一個過載構造器，令其接收一個字串引數，
 * 並在構造器中把你自己的訊息和接收的引數一起打印出來。
 * @author admin11
 * @date 2018年3月5日
 */
public class Exercise504 {

    public Exercise504() {
        System.out.println("Exercise504()");
    }

    public Exercise504(String str) {
        System.out.println("Exercise504(Strting str): " + str);
    }

    public static void main(String[] args) {
        new Exercise504();
        new Exercise504("hello");
    }
}

這裡寫圖片描述

/**
 * 練習5：建立一個名為Dog的類，它具有過載的bark()方法。此方法應根據不同的基本資料
 * 進行過載，並根據被呼叫的版本，打印出不同型別的狗吠(barking)、咆哮(howling)
 * 等資訊。編寫main()來呼叫所有不同版本的方法。
 * @author admin11
 * @date 2018年3月5日
 */

class Dog {
    public void bark() {
        System.out.println("barking");
    }

    public void bark(String str) {
        System.out.println("howling: " + str);
    }

    public void bark(int i) {
        System.out.println("howling: " + i);
    }
}

public class Exercise505 {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.bark();
        dog.bark("barking...");
        dog.bark(2);
    }
}

這裡寫圖片描述

/**
 * 練習6：修改前一個練習的程式，讓兩個過載方法各自接收兩個型別的不同的引數，
 * 但二者順序相反。驗證其是否工作。
 * @author admin11
 * @date 2018年3月5日
 */

class Dog2 {
    public void bark(int i, String str) {
        System.out.println("int i = " + i + ", String str = " + str);
    }

    public void bark(String str, int i) {
        System.out.println("String str = " + str + ", int i = " + i);
    }
}

public class Exercise506 {

    public static void main(String[] args) {
        Dog2 dog = new Dog2();
        dog.bark(6, "barking");
        dog.bark("howling", 7);
    }
}

這裡寫圖片描述

/**
 * 練習7：建立一個沒有構造器的類，並在main()中建立其物件，用以
 * 驗證編譯器是否真的自動加入了預設構造器。
 * @author admin11
 * @date 2018年3月5日
 */
public class Exercise507 {

    public static void main(String[] args) {
        Exercise507 e = new Exercise507();
        System.out.println(e);
    }
}

這裡寫圖片描述

/**
 * 練習8：編寫具有兩個方法的類，在第一個方法內呼叫第二個方法兩次：
 * 第一次呼叫時不使用this關鍵字，第二次呼叫時使用this關鍵字---
 * 這裡只是為了驗證它是起作用的，你不應該在實踐中使用這種方式。
 * @author admin11
 * @date 2018年3月9日
 */
public class Exercise508 {

    public void method1() {
        method2();
        this.method2();
    }

    public void method2() {
        System.out.println("method2");
    }

    public static void main(String[] args) {
        Exercise508 e = new Exercise508();
        e.method1();
    }
}

這裡寫圖片描述

/**
 * 練習9：編寫具有兩個（過載）構造器的類，並在第一個構造器
 * 中通過this呼叫第二個構造器。
 * @author admin11
 * @date 2018年3月9日
 */
public class Exercise509 {

    public Exercise509(String s,int i) {
        this(i);
        System.out.println(s);
    }

    public Exercise509(int i) {
        System.out.println(i);
    }

    public static void main(String[] args) {
        new Exercise509(27);
        new Exercise509("hello", 56);
    }
}

這裡寫圖片描述

10.

/**
 * 練習10：編寫具有finalize()方法的類，並在方法中列印訊息。
 * 在main()中為該類建立一個物件。試解釋這個程式的行為。
 * @author admin11
 * @date 2018年3月9日
 */
public class Exercise510 {

    @Override
    protected void finalize() throws Throwable {
        System.out.println("finalize() called");
    }

    public static void main(String[] args) {
        new Exercise510(); // 可能不會看到被呼叫的終結器，因為程式通常不會為收集器生成足夠的垃圾來執行
    }
}

這裡寫圖片描述

11.

/**
 * 練習11：修改前一個練習的程式，讓你的finalize()總會被呼叫。
 * @author admin11
 * @date 2018年3月12日
 */
public class Exercise511 {

    @Override
    protected void finalize() {
        System.out.println("finalize() called");
    }

    public static void main(String[] args) {
        new Exercise511();
        System.gc();
        System.runFinalization();
    }
}

這裡寫圖片描述

12.

/**
 * 練習12：編寫名為Tank的類，此類的狀態可以是“滿的”或“空的”。
 * 其終結條件是：物件被清理時必須處於空狀態。請編寫finalize()
 * 以檢驗終結條件是否成立。在main()中測試Tank可能發生的幾種使用方式。
 * @author admin11
 * @date 2018年3月12日
 */

class Tank {
    static int counter;
    int id = counter++;
    boolean full;
    public Tank() {
        System.out.println("Tank " + id + " created");
        full = true;
    }

    public void empty() {
        full = false;
    }

    @Override
    protected void finalize()  {
        if(full) {
            System.out.println("Error: tank " + id + " must be empty at cleanup");
        } else {
            System.out.println("Tank " + id + " cleaned up OK");
        }
    }

    @Override
    public String toString() {
        return "Tank " + id;
    }
}

public class Exercise512 {

    public static void main(String[] args) {
        new Tank().empty();
        new Tank();
        System.gc();
        System.runFinalization();
    }
}

這裡寫圖片描述

13.

/**
 * 練習13：驗證前面段落中的語句。
 * @author admin11
 * @date 2018年3月12日
 */
public class Exercise513 {

    public static void main(String[] args) {
        System.out.println("Exercise left to reader");
    }
}

這裡寫圖片描述

14.

/**
 * 練習14：編寫一個類，擁有兩個靜態字串域，其中一個在定義處初始化，
 * 另一個在靜態塊中初始化。現在，加入一個靜態方法用以打印出兩個欄位值。
 * 請證明它們都會在被使用之前完成初始化動作。
 * @author admin11
 * @date 2018年3月12日
 */
public class Exercise514 {

    static String s1 = "Initialized at definition";
    static String s2;
    static {
        s2 = "Initialized in satic block";
    }

    public static void main(String[] args) {
        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);
    }
}

這裡寫圖片描述

15.

/**
 * 練習15：編寫一個含有字串域的類，並採用例項初始化方式進行初始化。
 * @author admin11
 * @date 2018年3月12日
 */
public class Exercise515 {

    String str;
    {
        str = " instance initialization";
    }
    public Exercise515() {
        System.out.println("Default constructor: " + str);
    }

    public Exercise515(String str) {
        this.str = str;
        System.out.println("constructor: " + str);
    }

    public static void main(String[] args) {
        new Exercise515();
        new Exercise515("exercise");
    }
}

這裡寫圖片描述

16.

/**
 * 練習16：建立一個String物件陣列，併為每一個元素都賦值一個String。
 * 用for迴圈來列印該陣列。
 * @author admin11
 * @date 2018年3月12日
 */
public class Exercise516 {

    public static void main(String[] args) {
        String str[] = new String[3];
        str[0] = "hello";
        str[1] = "hi";
        str[2] = "exercise";

        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }

        String sa2[] = {
                "These", "are", "some", "strings"
                };
        for (int i = 0; i < sa2.length; i++) {
            System.out.println(sa2[i]);
        }
    }
}

這裡寫圖片描述

17.

/**
 * 練習17：建立一個類，它有一個接受一個String引數的構造器。在構造階段，
 * 列印該引數。建立一個該類的物件引用陣列，但是不實際去建立物件賦值給該陣列。
 * 當執行程式時，請注意來自對該構造器的呼叫中的初始化訊息是否列印了出來。
 * @author admin11
 * @date 2018年3月13日
 */
class Test {
    public Test(String s) {
        System.out.println("String constructor; s = " + s);
    }
}

public class Exercise517 {
    Test[] arr1 = new Test[5];
    public static void main(String[] args) {
        Test[] arr2 = new Test[5];
    }
}

這裡寫圖片描述

18.

/**
 * 練習18：通過建立物件賦值給引用陣列，從而完成前一個練習。
 * @author admin11
 * @date 2018年3月13日
 */
class Test2 {
    public Test2(String s) {
        System.out.println("String constructor; s = " + s);
    }
}

public class Exercise518 {

    static Test2[] arr1 = new Test2[5];
    public static void main(String[] args) {
        Test2[] arr2 = new Test2[5];
        for (int i = 0; i < arr2.length; i++) {
            //arr1[i] = new Test2("arr1" + i);
            arr2[i] = new Test2("arr2" + i);
        }
    }
}

這裡寫圖片描述

19.

/**
 * 練習19：寫一個類，它接收一個可變引數的String陣列。
 * 驗證你可以向該方法傳遞一個用逗號分隔的String列表，或是一個String[]。
 * @author admin11
 * @date 2018年3月13日
 */
public class Exercise519 {

    static void printStrings(String... str) {
        for (String string : str) {
            System.out.println(string);
        }
    }

    public static void main(String[] args) {
        printStrings("there", "are", "some", "Strings");
        printStrings(new String[]{"there", "are", "some", "Strings"});
    }
}

這裡寫圖片描述

20.

/**
 * 練習20：建立一個使用可變引數列表而不是普通的main()語法的main()。
 * 列印所產生的args陣列的所有元素，並用各種不同數量的命令列引數來測試它。
 * @author admin11
 * @date 2018年3月14日
 */
public class Exercise520 {

    public static void main(String... args) {
        for (String string : args) {
            System.out.println(string);
        }
    }
}

這裡寫圖片描述

21.

/**
 * 練習21：建立一個enum,它包含紙幣中最小面值的6種類型。
 * 通過values()迴圈並列印每一個值及其ordinal()。
 * @author admin11
 * @date 2018年3月15日
 */

enum PaperCurrencyTypes {
    ONE, TWO, FIVE, TEN, TWENTY, FIFTY
}

public class Exercise521 {

    public static void main(String[] args) {
        for (PaperCurrencyTypes s : PaperCurrencyTypes.values()) {
            System.out.println(s + ", ordinal " + s.ordinal());
        }
    }
}

這裡寫圖片描述

22.

/**
 * 練習22：在前面的例子中，為enum寫一個switch語句，
 * 對於每一個case，輸出該特定貨幣的描述。
 * @author admin11
 * @date 2018年3月15日
 */

enum PaperCurrencyType {
    ONE, TWO, FIVE, TEN, TWENTY, FIFTY
}

public class Exercise522 {

    public static void main(String[] args) {
        for (PaperCurrencyType s : PaperCurrencyType.values()) {
            switch (s) {
            case ONE:
                System.out.println("ONE");
                break;
            case TWO:
                System.out.println("TWO");
                break;
            case FIVE:
                System.out.println("FIVE");
                break;
            case TEN:
                System.out.println("TEN");
                break;
            case TWENTY:
                System.out.println("TWENTY");
                break;
            case FIFTY:
                System.out.println("FIFTY");
                break;
            default:
                System.out.println("defalut");
                break;
            }
        }
    }
}

這裡寫圖片描述

Thinking in Java 第四版完整版第五章練習題初始化與清理

Thinking in Java 第四版完整版第五章練習題，記錄一下(jdk1.8.0) 1. /** * 練習1：建立一個類，它包含一個未初始化的String引用。驗證該引用被Java初始化成了null。 * @author admin11 * @date 2

Thinking in Java 第四版完整版第九章練習題介面

Thinking in Java 第四版完整版第九章練習題，記錄一下(jdk1.8.0) 1. package com.test.c09; /** * 練習1：修改第八章練習9中的Rodent,使其成為一個抽象類。只要有可能， * 就將Rodent的方法宣告為抽象

Thinking in Java 第四版完整版第八章練習題多型

Thinking in Java 第四版完整版第八章練習題，記錄一下(jdk1.8.0) 1. /** * 練習1：建立一個Cycle類，它具有子類Unicycle、Bicycle和 * Tricycle。演示每一個型別的示例都可以經由ride()方法向上 *

Thinking in Java 第四版完整版第七章練習題複用類

Thinking in Java 第四版完整版第七章練習題，記錄一下(jdk1.8.0) 1. /** * 練習1：建立一個簡單的類。在第二個類中，將一個引用定義為第一個類 * 的物件。運用惰性初始化來例項化這個物件。 * @author admin11 *

Thinking in Java 第四版完整版第六章練習題訪問許可權控制

Thinking in Java 第四版完整版第六章練習題，記錄一下(jdk1.8.0) 1. package com.test.c06; /** * 練習1:在某個包中建立一個類，在這個類所處的包的外部建立該類的一個例項。 * @author admin11

Thinking in Java 第四版完整版第四章練習題

Thinking in Java 第四版完整版第四章練習題，記錄一下(jdk1.8.0) 1. /** * 練習1：寫一個程式，列印從1到100的值。 * @author admin11 * @date 2018年3月1日 */ public class Ex

Thinking in Java 第四版完整版第三章練習題

Thinking in Java 第四版完整版第三章練習題，記錄一下(jdk1.8.0) 1. import java.util.*; //import static net.mindview.util.Print.*; /** * 練習1：使用“簡短的”和正常的

Java程式設計思想第五章：初始化與清理

1. 用構造器初始化 Java中通過提供構造器，確保每個類的物件都可以得到初始化，構造器的形式為： className（）{ //--- } 可以看見程式在初始化物件的時候自動執行了構造方法。如果類中只有唯一的一個帶引數的構造器，那麼預設的無參構造器將不可用。

Thinking in Java 第四版完整版第二章練習題

Thinking in Java 第四版完整版第二章練習題，記錄一下(jdk1.8.0_111) 1. /** * 練習1: 建立一個類，它包含一個int域和一個char域，它們都沒有被初始化，將它們的值打印出來，以驗證Java執行了預設初始化。 * @autho

Java程式設計思想學習(五)----第5章：初始化與清理

隨著計算機革命的發展，“不安全”的程式設計方式已逐漸成為程式設計代價高昂的主因之一。 C++引入了構造囂（constructor）的概念，這是一個在建立物件時被自動呼叫的特殊方法。Java中也採用了構造器，並額外提供了“垃圾回收器”。對於不再使用的記憶體資源，垃圾回收器能自動將其釋放。 5.1 用構造器確

thinking in java (十四) ----- 集合之Stack

stack很簡單，繼承與Vector stack介紹 stack簡介 stack是棧，特性是先進後出（FILO） java中的stack是繼承自Vector（向量佇列）由於Vector是陣列實現的，這就意味著stack也是通過陣列實現的，而非連結串列。

Java程式設計思想第四版讀書筆記——第五章初始化與清理

第五章初始化與清理 1 用構造器確保初始化使用構造器（condructor），在建立物件時初始化。分為帶引數的初始化和不帶引數的初始化。 2 方法過載型別提升（向上提升）：int — long — float — double

Java程式設計思想第四版讀書筆記——第九章介面

這章介紹了介面卡設計模式和策略設計模式。第九章介面介面和內部類為我們提供了一種將介面與實現分離的更加結構化的方法。 1、抽象類和抽象方法 public abstract void f(); 建立抽象類是希望通過這個通用介面操縱一系列類。如果一個類

Java程式設計思想第四版讀書筆記——第十二章通過異常處理錯誤

第十二章通過異常處理錯誤 Java的基本理念是“結構不佳的程式碼不能執行”。 Java中異常處理的目的在於通過使用少於目前數量的程式碼來簡化大型、可靠的程式的生成，並且通過這種方式可以使程式設計師增加自信。 1、概念因為異常機制將保證能夠捕獲這個錯誤，所以不用小心翼翼

Java程式設計思想第四版讀書筆記——第四章控制執行流程

Java程式設計思想第四版第四章讀書筆記——控制執行流程。因為有些C++和android開發基礎，所以基礎知識筆記就不寫了，記些特別的需要注意的地方。第四章控制執行流程 1.true和false Java不允許我們將一個數字作為布林值使用，雖然這在C和C++裡是

Hadoop權威指南-大資料的儲存與分析第四版——學習筆記——第2章——1

MapReduce 適合處理半結構化的資料 MapReduce任務階段 Map階段+Reduce階段 Key-Value作為輸入輸出實現兩個函式：map(),reduce() Map階段輸入的Key：文字中的偏移量輸入的value：文字輸出的k-v給reduce處

讀書筆記：鳥哥基礎篇第四版（第一、二章磁碟劃分)

主要內容： Linux硬體的命名 MBR和GPT分割槽的區別，對應分割槽槽的命名，primary, extended, logical分割槽掛載點 Chap1 Linux 是什麼與如何學習 1.1 Linux是什麼 1.1.1 作業系統位置向下管

《現代作業系統（中文第四版）》筆記第一章引論

既然買了《現代作業系統》（《Modern Operating System》）這本書，那就好好學習一下吧，這是第一篇讀書筆記。第一章引論計算機系統總的來說分為軟體和硬體，如下圖所示。多數計算機有兩種執行模式：核心態和使用者態。軟體中最基礎的部分是作業系

Effective Java 第三版——83. 明智謹慎地使用延遲初始化

打破 alt 修飾 auto 理由們的所有作用 ldh Tips 書中的源代碼地址：https://github.com/jbloch/effective-java-3e-source-code 註意，書中的有些代碼裏方法是基於Java 9 API中的，所以JDK

《Java編程思想》筆記第五章初始化與清理

4.3 AI 創建 ati 清理共存 als this 方法簽名 1.構造器因為創建一個類的對象構造器就會自動執行，故初始化某些東西特好 2.方法重載方法名相同，參數列表不同。 2.1 區分重載方法方法重載後區別不同方法的就是方法簽名 -->參數類

Thinking in Java 第四版完整版 第五章練習題 初始化與清理

相關推薦

Thinking in Java 第四版完整版第五章練習題初始化與清理