Java 基礎篇之類與物件

類與物件

類、物件和引用的關係

類和物件的關係

類是物件的模版，物件是類的一個例項，一個類可以有很多物件
一個Java程式中類名相同的類只能有一個，也就是型別不會重名
一個物件只能根據一個類來建立

引用和類以及物件的關係

引用只能指向其所屬的型別的類的物件
相同型別的引用之間可以賦值
只能通過指向一個物件的引用，來操作一個物件，比如訪問某個成員變數

方法

引數傳遞方式

Java 總是採用按值呼叫。

基本型別的值傳遞

public class PrimitiveTransferTest {
    public static void swap(int a, int b) {
        int tmp = a;
        a = b;
        b = tmp;
        System.out.println("swap 方法裡 a 的值為: " + a + " b的值為: " + b);
    }

    public static void main(String[] args) {
        int a = 6;
        int b = 9;
        swap(a, b);
        System.out.println("交換結束後 a 的值為 " + a + " b的值為 " + b);
    }
}

/**
執行結果：
swap 方法裡 a 的值為: 9 b的值為: 6
交換結束後 a 的值為 6 b的值為 9
*/

分析圖：

java 程式總是從 main() 方法開始執行，main() 方法定義了 a、b 兩個區域性變數，兩個變數在 main 棧區中。在 main() 方法中呼叫 swap() 方法時，main() 方法此時還未結束，因此係統為 main 方法和 swap 方法分配了兩塊棧區，用於儲存 main 方法和 swap 方法的區域性變數。main 方法中的 a、b 變數作為引數傳入 swap 方法，實際上是在 swap 方法棧區中重新產生了兩個變數 a、b，並將 main 方法棧區中 a、b 變數的值分別賦給 swap 方法棧區中的 a、b 引數（這就是初始化）。此時系統記憶體中有兩個 a 變數、兩個 b 變數，只是存在於不同的方法棧區中而已。

引用型別的引數傳遞

public class ReferenceTransferTest {
    public static void swap(DataWrap dw) {
        int tmp = dw.a;
        dw.a = dw.b;
        dw.b = tmp;
        System.out.println("swap 方法裡， a 成員變數的的值為: " + dw.a + " b 成員變數的值為: " + dw.b);
    }

    public static void main(String[] args) {
        DataWrap dw = new DataWrap();
        dw.a = 6;
        dw.b = 9;
        swap(dw);
        System.out.println("交換結束後， a 成員變數的的值為: " + dw.a + " b 成員變數的值為: " + dw.b);
    }
}

/**
swap 方法裡， a 成員變數的的值為: 9 b 成員變數的值為: 6
交換結束後， a 成員變數的的值為: 9 b 成員變數的值為: 6
*/

你可能會疑問，dw 物件的成員變數 a、b的值也被替換了，這跟前面基本型別的傳遞完全不一樣。這非常容易讓人覺得，呼叫傳入 swap 方法的就是 dw 物件本身，而不是它的複製品。其實傳遞的依然是 dw 的值。

分析圖：

系統一樣賦值了 dw 的副本，只是關鍵在於 dw 只是一個引用變數，它儲存的值只是一段記憶體地址，將該記憶體地址傳遞給 swap 棧區，此時 swap 棧區的 dw 和 main 棧區的 dw 的值也就是記憶體地址相同，該段記憶體地址指向堆記憶體中的 DataWrap 物件。對 swap 棧區的 dw 操作，也就是對 DataWrap 物件操作。

過載

過載：同一個類中，方法名相同，引數列表不同。

當呼叫被過載的方法時，根據引數的個數和型別判斷應該呼叫哪個過載方法，引數完全匹配的方法將被執行。

構造器

預設無參構造器

僅當類沒有定義任何構造器的時候，系統才會提供一個預設的構造器。這個構造器將所有的例項域設定為預設值。

自定義構造器

當類中有自定義構造器時，系統不會再提供預設的構造器

靜態常量

public static final double PI = 3.1415926

靜態方法

在類載入的時候就存在了，不依賴於任何類的任何例項。

建議通過類名呼叫，而不是通過例項物件呼叫，否則很容易混淆概念。

繼承

java 使用 extends 作為繼承的關鍵字，有趣的是 extends 是擴充套件的意思，並不是繼承。但是 extends 很好體現了子類和父類的關係，子類是對父類的擴充套件，子類是一種特殊的父類。擴充套件更加準確。ps：這個理解真的是流弊啊。

子類重寫父類方法（覆蓋）

方法的重寫遵循 “兩同兩小一大”規則：

方法名相同、形參列表相同
子類方法返回的值型別應比父類方法返回值型別更小或相等，子類方法宣告丟擲的異常類應該比父類方法宣告丟擲的異常類更小或相等
子類方法訪問許可權應該比父類方法的訪問許可權更大或相等

子類中呼叫父類被覆蓋的方法

如果被覆蓋的方法是例項方法，使用 super 關鍵字
如果被覆蓋的方法是類方法，使用父類類名
子類不能呼叫父類中被 private 修飾的方法和屬性

子類呼叫父類構造器

子類不能繼承父類的構造器。在子類的構造器中，如果沒有顯式使用 super 呼叫父類的建構函式，那麼系統一定會在子類構造器執行之前，隱式的呼叫父類的無參構造器
在子類構造器中，可以使用 super 顯式呼叫父類構造器，但 super 語句必須在第一行

多型

向上型別轉換

Java 引用變數有兩個型別。如果編譯時型別和執行時型別不一致，就可能出現多型。

編譯時型別：由宣告該變數時使用的型別決定
執行時型別：由實際賦給該變數的物件決定

示例程式碼：

public class BaseClass {
    public int book = 6;

    public void base() {
        System.out.println("父類的普通方法");
    }

    public void test() {
        System.out.println("父類的test方法");
    }
}

public class SubClass extends BaseClass {
    public String book = "輕量級 Java EE";

    public void test() {
        System.out.println("子類的test方法");
    }

    public void sub() {
        System.out.println("子類的sub方法");
    }

    public static void main(String[] args) {
        BaseClass ploymophicBc = new SubClass();
        System.out.println(ploymophicBc.book);
        ploymophicBc.base();
        ploymophicBc.test();
        // 因為 ploymophicBc 的編譯時型別是 BaseClass
        // BaseClass 類沒有提供 sub 方法，所以下面程式碼編譯時會出錯
        // ploymophicBc.sub();
    }
}

上面的例子中，引用變數 ploymophicBc 比較特殊，它的編譯時型別是 BaseClass，而執行時型別是 SubClass。

ploymophicBc.sub() 這行程式碼會在編譯時報錯，因為 ploymophicBc 編譯時型別為 BaseClass，而 BaseClass 中沒有定義 sub 方法，因此編譯時無法通過。

但是注意，ploymophicBc.book 的值為 6，而不是 ”輕量級 Java EE“。因為物件的例項變數不具備多型性，系統總是試圖訪問它編譯時型別所定義的成員變數，而非執行時。

子類其實是一種特殊的父類，因此 java 允許把父類的引用指向子類物件，這被稱為向上轉型（upcasting），向上轉型由系統自動完成。

可以呼叫哪些方法，取決於引用型別（編譯時）。
具體呼叫哪個方法，取決於引用指向的例項物件（執行時）。

向下型別轉換

問題：引用變數在程式碼編譯過程中，只能呼叫它編譯時型別具備的方法，而不能呼叫它執行時型別具備的方法

解決：強制轉換成執行時型別

方法：引用型別之間的轉換隻能在有繼承關係的兩個型別之間進行，否則編譯出錯。如果想把一個父類引用變數的編譯時型別轉換成子類型別，則這個引用變數的執行時型別得是子類型別，否則引發 ClassCastException

示例程式碼：

//建立子類物件  
Dog dog = new Dog();  
  
// 向上型別轉換(型別自動提升),不存在風險  
Animal animal = dog;  
  
// 風險演示 animal 指向 Dog 型別物件，沒有辦法轉化成 Cat 物件，編譯階段不會報錯，但是執行會報錯
Cat cat = (Cat)animal; // 1.編譯時按 Cat 型別  2. 執行時 Dog 型別，型別不匹配，直接報錯

instanceof

為了解決強制型別轉換，可能引發的 ClassCastException 異常，引入 instanceof 運算子。

instanceof 運算子的含義：用於判斷左邊的物件（執行時型別或者叫實際型別）是否是右邊的類或者其子類、實現類的例項。如果是返回 true，否則返回 false。

在之前的程式碼中，強制型別轉換前使用 instanceof 判斷：

if (anmial instanceof Cat) {
    Cat cat = (Cat)animal;
}

final 修飾符

final 修飾類

不能被繼承

final 修飾方法

不可被子類覆蓋

final 修飾變數

特徵：變數一旦被初始化，便不可改變

初始化：定義時直接賦值、藉助建構函式

對於基本型別域而言，其值是不可變的。

對於引用型別變數而言，它儲存的僅僅只是個引用。final 只保證這個變數所引用的地址不會改變，即一直引用同一個物件。但這個物件自身內容完全可以發生改變。

Object 類

toString

toString 用於輸出物件的自我描述資訊。

Object 類提供的 toString 返回該物件實現類的 "類名 + @ + hashCode"。通常需要重寫該方法。

==

對於數值型別的基本變數，只要兩個變數的值相等（不需要資料型別完全相同），就返回 true。

對於兩個引用型別的變數，只有它們指向同一個物件時，== 判斷才會返回 true。

equals

equals 方法是 Object 類提供的一個例項方法。對於引用變數，只有指向同一個物件時才返回 true。一般需要重寫 equals 方法。

重寫 equals 方法的示例：

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj !=null && obj.getClass() == Person.class) {
            Person personObj = (Person)obj;
            if (this.getIdStr().equals(personObj.getIdStr())) {
                return true;
            }
        }
        return false;
    }

equals 為 true，hashCode 就應該相等，這是一種約定俗稱的規範。即 equals 為 true 是 hashCode 相等的充分非必要條件。

介面

設計思想

介面體現的是規範和實現分離的設計哲學，讓軟體系統的各元件之間面向介面耦合，是一種鬆耦合的設計
介面定義的是多個類共同的公共行為規範，這些行為是與外部交流的通道，意味著介面通常是定義一組公共方法

定義

介面的修飾符，只能是 public 或者 default
由於介面定義的是一種規範，所以接口裡不能包含構造器和初始化塊定義，只能包含靜態常量、方法（只能是抽象方法，類方法和預設方法）以及內部類、內部介面、內部列舉
接口裡的常量只能是靜態常量，預設使用 public static final 修飾
接口裡的內部類、內部介面、內部列舉，預設使用 public static 修飾
接口裡的抽象方法不能有方法體，但類方法和預設方法必須有方法體。

方法說明

介面中定義抽象方法可以省略 abstract 關鍵字和修飾符，預設修飾符為 public。

Java 8 新增允許在介面中定義預設方法，使用 default 修飾。預設情況下，系統使用 public 修飾預設方法。

Java 8 新增允許在介面中定義私有方法。

Java 8 新增允許在介面中定義靜態方法。靜態方法可以被實現的介面的類繼承。

使用

一個類可以實現一個或多個介面。

一個類實現一個或多個介面，這個類必須重寫所實現的介面中的所有抽象方法。否則，該類必須被定義成抽象類，保留從父介面繼承到的抽象方法。

介面不能用來建立例項，但是可以用於宣告引用型別的變數，該變數必須指向實現該介面的類的例項物件。

抽象類

抽象類與普通類的區別，可以概括為 “有得有失”。

得，是指抽象類多了一個能力，抽象類可以包含抽象方法

失，是指抽象類失去了一個能力，抽象類不能用於建立例項

抽象類和普通類的區別：

抽象類使用 abstract 修飾
抽象類可以和普通類一樣可以包含成員變數、方法、構造器、初始化塊、內部類。但抽象類不能被例項化，抽象類的構造器主要用來被子類呼叫
抽象類可以不包含抽象方法，但是含有抽象方法的類必須被定義為抽象類

抽象類的設計思想：抽象類是模板模式的設計模式體現。抽象類是從多個具體類中抽象出來的父類，具有更高層次的抽象。從多個具有相同特徵的類中抽象出一個抽象類，以這個抽象類為其子類的模板，避免子類設計的隨意性

內部類

成員內部類

非靜態內部類

public class Cow {
    private double weight;

    public Cow() {
    }

    public Cow(double weight) {
        this.weight = weight;
    }
    // 定義一個非靜態內部類
    private class CowLeg {
        private double length;
        private String color;

        public CowLeg() {}
        public CowLeg(double length, String color) {
            this.length = length;
            this.color = color;
        }
        public double getLength() {
            return this.length;
        }
        public void setLength(double length) {
            this.length = length;
        }
        public String getColor() {
            return this.color;
        }
        public void setColor(String color) {
            this.color = color;
        }
        public void info() {
            System.out.println("當前牛腿的顏色是 " + this.color + ", 長 " + this.length);
            // 直接訪問外部類的 private 修飾的成員變數
            System.out.println("該牛腿所屬的奶牛重: " + weight);
        }
    }

    public void test() {
        CowLeg cl = new CowLeg(1.12, "黑白相間");
        cl.info();
    }
    public static void main(String[] args) {
        Cow cow = new Cow(378.9);
        cow.test();
    }
}

在非靜態內部類裡可以直接訪問外部類的 private 成員，這是因為在非靜態內部類物件裡，儲存了一個它所寄生的外部類物件的引用。如下圖：

如果外部類成員變數、內部類成員變數與內部類裡方法的區域性變數名同名

直接訪問區域性變數
this，訪問內部類例項的變數
外部類類名.this.varName 訪問外部類例項變數

外部類不能直接訪問非靜態內部類的成員，無論非靜態內部類的成員是什麼修飾符修飾的。只能顯示建立非靜態內部類物件來訪問其例項成員。

靜態內部類（類內部類）

如果用 static 修飾一個內部類，則這個內部類就屬於外部類本身，而不屬於外部類的某個物件。因此也叫做類內部類。即靜態內部類是外部類的一個靜態成員。

靜態內部類可以包含靜態成員，也可以包含非靜態成員。

靜態內部類不能訪問外部類的例項成員，只能訪問外部類的類成員。

外部類依然不能直接訪問靜態內部類的成員，但可以使用靜態內部類的類名作為呼叫者來訪問靜態內部類的類成員，也可以使用靜態內部類物件作為呼叫者來訪問靜態內部類的例項成員。

在外部類之外訪問內部類

在外部類以外的地方訪問內部類（包括靜態和非靜態兩種），則內部類不能使用 private 修飾，private 修飾的內部類只能在外部類內部使用。對於使用其他訪問修飾符的內部類，按照訪問修飾符範圍訪問。

省略訪問控制符的內部類，只能被與外部類處於同一個包中的其他類所訪問
使用 protected 修飾的內部類，可被與外部類處於同一個包中的其他類和外部類的子類訪問
使用 public 修飾符的內部類，可在任何地方被訪問

在外部類之外使用非靜態內部類

由於非靜態內部類的物件必須寄生在外部類的物件裡，因此在建立非靜態內部類物件之前，必須先建立其外部類物件。

示例程式碼，如下：

public class Out {
    // 使用預設訪問控制符，同一個包中的其他類可以訪問該內部類
    class In {
        public In(String msg) {
            System.out.println(msg);
        }
    }
}

public class CreateInnerInstance {
    public static void main(String[] args) {
        Out.In in = new Out().new In("Test Msg");
        /*
        上面程式碼可以改為如下三行程式碼
        使用 OutterClass.InnerClass 的形式定義內部類變數
        Out.In in;
        建立外部類例項，非靜態內部類例項將寄生在該例項中
        Out out = new Out();
        通過外部類例項和new來呼叫內部類構造器建立非靜態內部類例項
        in = out.new In("Test Msg");
        */
    }
}

下面定義了一個子類繼承了 Out 類的非靜態內部類 In 類

public class SubClass extends Out.In{
    // 顯示定義 SubClass 的構造器
    public SubClass(Out out){
        out.super("hello");
    }
}

上面的程式碼可能看起來很怪，其實很正常：非靜態內部類 In 類的構造器必須使用外部類物件來呼叫，程式碼中 super 代表呼叫 In 類的構造器，而 out 則代表外部類物件。

如果需要建立 SubClass 物件時，必須建立一個 Out 物件。因為 SubClass 是非靜態內部類 In 的子類，非靜態內部類 In 物件裡必須有一個對 Out 物件的引用，其子類 SubClass 物件裡也應該持有對 Out 物件的引用。當建立 SubClass 物件時傳給該構造器的 Out 物件，就是 SubClass 物件裡 Out 對應引用所指向的物件。

結合上面兩段程式碼，非靜態內部類 In 物件和 SubClass 物件都必須持有指向 Outer 物件的引用，區別是建立兩種物件時傳入 Out 物件的方式不同：當建立非靜態內部類 In 類的物件時，必須通過 Outer 物件來呼叫 new 關鍵字；當建立 SubClass 類的物件時，必須使用 Outer 物件作為呼叫者來呼叫 In 類的構造器

在外部類之外使用靜態內部類

因為靜態內部類是外部類類相關的，因此建立靜態內部類物件時無需建立外部類物件。

public class CreateStaticInnerInstance {
    public static void main(String[] args) {
        StaticOut.StaticIn in = new StaticOut.StaticIn();
        /* 上面的程式碼可改為如下兩行程式碼
        使用 OuterClass.InnerClass 的形式定義內部類變數
        StaticOut.StaticIn in;
        通過 new 呼叫內部類構造器建立靜態內部類例項
        in = new StaticOut.StaticIn();
        */
    }
}

因為呼叫靜態內部類的構造器時不需要使用外部類物件，所以建立靜態內部類的子類也比較簡單。下面程式碼為靜態靜態內部類 StaticIn 定義了一個空的子類

public class StaticSubClass extends StaticOut.StaticIn {}

區域性內部類

匿名內部類

匿名內部類適合建立只需要一次使用的類，建立匿名內部類時會立即建立一個該類的例項，這個類定義立即消失，匿名類不能重複使用。

匿名類是用來建立介面或者抽象類的例項的。

匿名內部類不能定義構造器。因為匿名內部類沒有類名，所有無法定義構造器。但匿名內部類可以定義初始化塊，可以通過例項初始化塊來完成構造器需要完成的事情。

定義匿名內部類格式如下：

new 實現介面 | 抽象父類構造器(實參列表)
{
    匿名內部類的類體部分
}

最常用的建立匿名內部類的方式是需要建立某個介面型別的物件，如下

public interface ProductA {
    public double getPrice();
    public String getName();
}

public class AnonymousTest {
    public void test(ProductA p) {
        System.out.println("Buy a" + p.getName() + "Cost " + p.getPrice());
    }
    public static void main(String[] args) {
        AnonymousTest ta = new AnonymousTest();
        // 呼叫 test() 方法時，需要傳入一個 Product 引數
        // 此處傳入其匿名實現類的例項
        ta.test(new ProductA() {
            @Override
            public double getPrice() {
                return 567.8;
            }

            @Override
            public String getName() {
                return "APG Card";
            }
        });
    }
}

通過繼承抽象父類來建立匿名內部類時，匿名內部類將擁有和父類相同形參列表的構造器。看下面一段程式碼

public abstract class Device {
    private String name;
    public abstract double getPrice();
    public Device() {};
    public Device(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class AnonymousInner {
    public void test(Device d) {
        System.out.println("Buy a" + d.getName()+ "Cost" + d.getPrice());
    }
    public static void main(String[] args) {
        AnonymousInner ai = new AnonymousInner();
        // 呼叫有引數的構造器建立 Device 匿名實現類的物件
        ai.test(new Device("電子顯示器") {
            @Override
            public double getPrice() {
                return 67.8;
            }
        });

        // 呼叫無引數的構造器建立 Device 匿名實現類的物件
        Device d = new Device() {
            // 初始化塊
            {
                System.out.println("匿名內部類的初始化塊");
            }
            // 實現抽象方法
            @Override
            public double getPrice() {
                return 56.2;
            }
            // 重寫父類的例項方法
            public String getName() {
                return "keyboard";
            }
        };
        ai.test(d);
    }
}

歡迎關注我的公眾號