Java超簡明入門學習筆記（三）

Java編程思想第4版學習筆記（三）

第五章 初始化與清理（構造器和垃圾回收機制）

 

      Java有和C++類似的構造函數來為新創建的對象執行初始化及完成一些特殊的操作，有的類數據成員可能會被初始化幾次，它們的初始化次序和次數是根據程序決定的，可以用重載的構造函數以不同的形式對一個對象初始化，重載的構造函數之間可以通過this互相調用。最后，本章講了finalize()函數和簡單的GC機制，也提到了如何創建一個數組。

 

     知識點1 ：P76，5.1，定義構造函數

      當對象被創建時，構造函數會自動被調用，構造器的函數名和類名相同，無返回值類型（也不是void類型，就是不需要任何類型），可以有任意個參數，在函數體里寫上你想讓該類對象被創建時會發生的事情。創建對象時要給對象符合構造器（構造函數的另一種說法）要求的參數。不需要任何參數的構造器被稱為“無參構造器”或“默認構造器”。

     如果你寫的類沒有任何構造函數，Java會自動幫你創建出一個無參構造器，它做的事只是把類內成員初始化為0或那個類型默認的初始值。如果你寫了一個或多個構造器（無論帶不帶參數），系統將不再自動生成一個無參構造器。

     一個含有顯式構造器的類的實例被初始化的順序是這樣的：

     在構造函數被調用之前，靜態變量首先被初始化為默認值或類內初始值（這一行為被這本書稱為指定初始化，具體做法是在類字段定義時就用字段=對象;的方式初始化字段），然后一般變量首先被初始化為默認值或類內初始值。之后，會執行接下來會提到的“初始化子句”，最后，構造函數如果有初始化類數據成員的語句，則，這些語句依次對數據成員初始化。另外，靜態類數據成員只要被訪問，哪怕沒有實例存在，也會完成初始化。

 

     知識點2 ：P77，5.2，方法重載

      同一個類里可以有多個同名函數，這些函數的參數類型或參數數量不一樣使使用者可以通過不同的參數組合調用一個名字的參數，這種形式叫方法重載。定義一個重載的函數，只需要通過正常的定義函數的形式，把函數名設定為想要重載的函數名，把參數列表變成不一樣的就行了。

     重載之后，如果傳入的實參類型並非任意一個重載函數需要的類型，但經過非窄化轉換仍能匹配所有的重載函數需要的參數類型，這個參數就會類型提升為更接近它的那一個函數需要的參數類型，參與運算。

 

     知識點3 ：P84，5.4，this

      this可以出現在非靜態函數體內，代表當前函數所屬對象的一個引用。在一個構造器中調用另一個構造器，必須使用this(構造器參數);的形式，一個構造器中只能通過這種方法調用一次別的構造器，且這個調用要放在函數最開始。

 

     知識點4 ：P87，5.5，垃圾回收與finalize()函數

     垃圾回收器要回收對象的時候，首先要調用這個類的finalize方法)，一般的純Java編寫的Class不需要重新覆蓋這個方法，因為Object已經實現了一個默認的，除非我們要實現特殊的功能。如果想覆蓋Object的finalize方法，只需聲明一個 protected void finalize( ) { } 這樣的函數。在函數里寫一些你想要Java的GC回收對象之前你想做的事情。

     Java中有一個有趣的函數，叫System.gc();，這個函數的作用是提醒JVM：程序員覺得應該進行一次垃圾回收了。至於到底JVM真的開始了垃圾回收，還是沒有理你的這個意願，認為根本沒必要浪費時間和資源進行垃圾回收，那就是JVM自己的事情了。

     Java垃圾回收的機理在於遍歷對象和對象的引用，只要發現某個對象不可達，即在代碼執行的某一過程中無法通過任何引用（或者這個對象目前根本就沒有引用）訪問這個對象，這個對象就失去的存在的意義，會被回收。不過具體的回收時機，不同的JVM實現上也不盡相同。

 

     知識點5 ：P87，5.7.3，靜態初始化子句和實例初始化子句

     如果你需要在構造函數里額外執行一些語句，又實在懶得寫構造函數，你可以使用如下所示的方法（靜態/實例初始化子句）實現這個目的。紅色的部分就是初始化子句。初始化子句會在默認初始化和構造器初始化之間被調用。

class staticClass{
    static int i = 0;
    static{
        i = 9;
        System.out.println("i = 9");
    }
}

class sampleClass{
    int i =0;
    {
        i = 89;
        System.out.println("i = 89");
    }

}

 

     知識點6 ：P98，5.8，數組

     數組是一種能夠容納多個元素的重要結構。要定義一個某種類型的數組，只需這樣做：類型名[] 數組名; 或者 類型名 數組名[]; ，比如 int[] a1;    和一些語言不同，不能夠用類似C/C++那樣的方式指定數組的大小，只能創建一個數組的引用（即數組名）來操控它代表的真正數組對象。使用一個空(值為null)的數組引用也將出現錯誤，因此要在這個數組引用初始化之后再使用。可以使用初始化表達式，即一對大括號包圍起來的一個元素的列表來初始化數組，比如int[] a = { 1,2,3,4 };，這種初始化方法只能夠用於數組定義之處。也可以把另一個數組的引用所指代的對象傳遞給這個引用，比如int[] a2 = a;。最后，還可以通過new關鍵字創建數組對象和其引用，比如int[] c = new int[30]; 或者 int[] a = new int[]{1,2,3,4}; 來初始化。

     正如上一章所說，數組可被用於foreach循環。

     數組對象有一個叫做toString的方法，這個方法不需要參數，可以把數組轉換成合適的字符串。也可以使用Array.toString(數組名)的靜態方法達到同樣的目的。

 

     知識點7 ：P102，5.8.1，可變參數列表

     我們有時候可能需要這么一種函數，這個函數需要傳入一些參數，這些參數類型是固定的，但我們並不知道會傳入幾個這個類型的參數。這時我們就需要這個特性。我們可以在參數列表里放一個數組來解決這個問題。

     比如 void func(int 1, char[] c); 我們想要使用這個函數，就可以這么調用它： func(1, new char[]{'a','b','c'}); 不過這種寫法需要顯式創建一個數組對象並且傳入，我們可以用這種寫法代替原來的函數定義void func(int i, char... c){}; ，這種定義方式可以允許我們這么調用它：func(1,'a','b','c'); ，大大簡略了語法。Java的函數重載時，即使實參可以轉化為多種函數需要的形參類型，不過Java有粒度很細的優先轉換的規則，可以使這個調用總能匹配到一個“最容易轉化”的，因此不會產生二義性調用（C++函數匹配則只有5個等級，每個等級間的各個調用形式是優先度一致的，因此可能產生二義性調用）。

     可變參數列表必須放在參數列表的最后且每個函數只能有一個可變形參。

 

     知識點8 ：P105，5.9，枚舉類型

     和其他主流語言一樣，Java也提供了枚舉類型，它的關鍵字是enum，用來方便的定義枚舉類型，定義枚舉類型的方式類似與定義一個類：enum testSize{ SMALL, MIDIUM, LARGE }; ，使用時，可以為testSize枚舉類型創建一個實例：testSize s = testSize.SMALL; 枚舉類型的對象有toString，ordinal等方法，ordinal()返回一個從0開始的當前枚舉值在枚舉類型中被定義時的次序。此外，枚舉類型還提供values()靜態函數，返回所有枚舉情況的集合，使編程者可以遍歷每個枚舉值。

 

     第五章 練習題

     練習1、2： 創建一個類，它包含一個未初始化的String域，一個在定義時就初始化的String域，一個構造器初始化的String域。驗證第一個String域被默認初始化為了null，探究第二和第三個String域的差異。

class StringTest{
    StringTest(){
        s3 = "4567";
    }

    String s1;
    String s2 = "1234";
    String s3;
}

public class MainTest {
    public static void main(String[] args) {
        StringTest st = new StringTest();
        System.out.println(st.s1);
        System.out.println(st.s2);
        System.out.println(st.s3);
    }
}

     練習3、4：創建一個帶無參構造器的類，在構造器中打印一條信息，為這個類創建一個對象。在為這個類創建一個重載構造器，這個構造器需要一個字符串做參數，並把接收的字符串也打印出來。

class Test{
    Test(){
        System.out.println("Test");
    }

    Test(String s){
        System.out.println(s+"test");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Test t = new Test();
        Test t2 = new Test("1234");
    }
}

     練習5、6：創建一個名為Dog的類，它具有重載的bark()方法，此方法根據不同的基本數據類型進行重載，並根據被調用的版本，打印出不同類型的barking，howling等信息。編寫對應的主函數調用所有不同版本的方法。再試着寫兩個構造函數，它們都需要兩個不同類型的參數，但是這兩個構造函數需要的參數類型順序正好相反，試試調用它們。

class Dog{
    Dog(int i){
        System.out.println("barking");
    }

    Dog(double d){
        System.out.println("howling");
    }

    Dog(char c){
        System.out.println("Meow~");
    }

    Dog(int i, boolean b){
        System.out.println("I B");
    }

    Dog(boolean b, int i){
        System.out.println("B I");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Dog d1 = new Dog(1);
        Dog d2 = new Dog(1.5);
        Dog d3 = new Dog('c');

        Dog bi1 = new Dog(1,true);
        Dog bi2 = new Dog(true,1);
    }
}

     練習7：創建一個沒有構造器的類，並在main()中創建其對象，用以驗證編譯器是否真的自動加入了默認構造器。

class Test{
    int i;
    double d;
}

public class MainTest {
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.i);
        System.out.println(t.d);
    }
}

     練習8：編寫具有兩個方法的類，在第一個方法內調用第二個方法兩次：第一次調用時不使用this關鍵字，第二次調用使用關鍵字，來驗證this關鍵字的作用。

class Test{
    void method1(){
        method2();
        this.method2();
    }

    void method2(){ System.out.println("Ah,be called!!"); }
}

public class MainTest {
    public static void main(String[] args) {
        Test t = new Test();
        t.method1();
    }
}

     練習9：編寫具有兩個（重載）構造器的類，並在第一個構造器中通過this調用第二個構造器。

class Test{
    Test(String s, double i){
        this(i);
        ss = s;

        System.out.println("name: "+ss);
        System.out.println("Area: "+ii);
    }

    Test(double i){
        ii = i*i*3.14;
    }

    String ss;
    double ii;
}

public class MainTest {
    public static void main(String[] args) {
        Test t = new Test("Circle",2);
    }
}

     練習10、11：編寫具有finalize()方法的類，並在方法中打印消息，在main()中為該類創建一個對象，研究finalize和System.gc()和finalize()的聯系。

class Test{
    protected void finalize(){
        //super.finalize();
        System.out.println("Ah!!NO!!!");
    }
}

public class MainTest {
    public static void main(String[] args) {
        Test t = new Test();
        System.gc();
    }
}

     練習12：編寫名為Tank的類，此類的狀態可以是“滿的”或者“空的”，其終結條件是：對象是空的，編寫finalize()函數以在gc之前檢驗對象狀態。

class Tank{
    protected void finalize(){
        //super.finalize();
        if(isFull){
            System.out.println("Not Good");
        }
        else{
            System.out.println("Good!");
        }
    }

    boolean isFull = false;
}

public class MainTest {
    public static void main(String[] args) {
        Tank t = new Tank();
        System.gc();
    }
}

     練習13：調試書上代碼，略。

     練習14：編寫一個類，擁有兩個靜態字符串域，其中一個在定義處初始化，另一個在靜態塊中初始化。現在加入一個靜態方法打印這兩個字段的值，查看它們是否都會在被使用之前完成初始化動作。

class Test{
    static String s1 = "1234";
    static String s2;
    static{
        s2 = "4567";
    }

    static void func(){
        System.out.println(Test.s1);
        System.out.println(Test.s2);
    }
}

public class MainTest {
    public static void main(String[] args) {
        Test.func();
    }
}

     練習15：編寫一個含有字符串域的類，並采用實例初始化方式進行初始化。

class Test{
    String s1;
    {
        s1 = new String("1234");
    }
}

     練習16：創建一個String對象數組，並為每一個元素都賦值一個String，用for循環來打印此數組。

public class MainTest {
    public static void main(String[] args) {
        String[] arrayString = {"1111","2222","3333","4444"};
        for(String s:arrayString)
        {
            System.out.println(s);
        }
    }
}

     練習17、18：創建一個類，它有一個構造器，這個構造器接收一個String類型的參數。在構造階段，打印此參數。創建一個該類對象的引用數組，但是不實際地創建對象賦值給該數組。試着運行程序。再試着通過創建對象，再賦值給引用數組，從而完成程序。

class Test{
    Test(String s){
        System.out.println(s);
    }
}

public class MainTest {
    public static void main(String[] args) {
        Test[] arrayTest = new Test[]{
                new Test("123"),
                new Test("456")
        };
    }
}

     練習19：創建一個類，它的構造函數接受一個可變參數的String數組。驗證你可以向該方法傳遞一個用逗號分隔的String實參列表，或是一個String[]。

class Test{
    Test(String... s){
    }
}

public class MainTest {
    public static void main(String[] args) {
        Test t1 = new Test("111","222");
        Test t2 = new Test(new String[]{"333","444"});
    }
}

     練習20：創建一個使用可變參數列表而不是用普通main()語法的主函數main()，打印args數組的傳入的命令行參數。

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

     練習21、22：創建一個enum，它包含紙幣中最小面值的6種類型，通過values()循環並打印每一個值以及其ordinal()。 最后再試着使用帶enum類型的switch語句。

enum CNY{
    CNY1,CNY5,CNY10,CNY20,CNY50,CNY100;
}

public class MainTest {
    public static void main(String[] args) {
        for (CNY temp : CNY.values()) {
            System.out.println(temp + " " + temp.ordinal());
        }

        CNY cnyTemp = CNY.CNY5;
        switch (cnyTemp){
            case CNY1:
                System.out.println("1 Yuan");
                break;

            case CNY5:
                System.out.println("5 Yuan");
                break;

            case CNY10:
                System.out.println("10 Yuan");
                break;

            case CNY20:
                System.out.println("20 Yuan");
                break;

            case CNY50:
                System.out.println("50 Yuan");
                break;

            case CNY100:
                System.out.println("100 Yuan");
                break;

            default:
                System.out.println("Error : Fake Money");
        }
    }
}