深入理解 Java 運算子與修飾符 | 重要概念、細節 | equals 比較

A. 正數位移：兩者位移後結果相同

public void movePos_1() {
    int value = 15 >> 1;

    System.out.println("15 >> 1:" + Integer.toBinaryString(value));
}

public void movePos_2() {
    int value = 15 >>> 1;

    System.out.println("15 >>> 1:" + Integer.toBinaryString(value));
}

B. 負數位移：兩者位移後 結果不相同，可以看到 >>> 符號位移後，複數變正數

public void moveNeg_1() {
    int value = -1 >> 1;

    System.out.println("-1 >> 1:" + Integer.toBinaryString(value) + ", decimal:" + value);


public void moveNeg_2() {
    int value = -1 >>> 1;

    System.out.println("-1 >>> 1:" + Integer.toBinaryString(value) + ", decimal:" + value);
}

在靜態檢查時，兩個物件必須要有繼承關係（而且是同一繼承分支上）才可以使用 == 運算子，否則不用編譯也不會通過！

繼承關係如下：

class Fruit { }

class Apple extends Fruit { }

class Banana extends Fruit { }

靜態語言撰寫，測試

public void staticLangCheck_1() {
    Fruit fruit = new Fruit();
    Banana banana = new Banana();

    System.out.println(fruit == banana);
}


public void staticLangCheck_2() {
    Apple apple = new Apple();                // 兩個類之間沒有直向關係！
    Banana banana = new Banana();

    // 不合法！直接編譯不過
    System.out.println(apple == banana);
}

JVM 在判斷 == 符號時，以「多型」時又可以分為兩個角度來看

A. 參考值 reference：這是最直接的比較方式，即兩個參考是否指向同一個物件，比較的是兩個 物件的參考(ref)是否相同

public void runtimeCheck() {
    Apple greenApple = new Apple();
    Apple redApple = new Apple();

    System.out.println(greenApple == redApple);        // false
}

B. 多型別時的比較：在多型別的情況下，比較兩個物件的是否相同

public static void runtimeCheck() {
    Apple greenApple = new Apple();
    Fruit redApple = greenApple;        // 兩者雖然宣告不同，但是仍是同一個物件

    System.out.println(greenApple == redApple);    // true
}

它預設是比較當前物件與傳入物件的參考

// Object.java

public boolean equals(Object obj) {
    return (this == obj);
}

像是 String 類的 equals 方法就是比較字串的內容

// String.java

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String aString = (String)anObject;
        if (!COMPACT_STRINGS || this.coder == aString.coder) {
            // 查看 StringLatin1#equals 方法
            return StringLatin1.equals(value, aString.value);
        }
    }
    return false;
}


// StringLatin1.java
public static boolean equals(byte[] value, byte[] other) {
    if (value.length == other.length) {
        for (int i = 0; i < value.length; i++) {
            if (value[i] != other[i]) {
                return false;
            }
        }
        return true;
    }
    return false;
}

● equals 方法 & == 運算子

以 String 類來說，要注意你要比較的是 String 的內容，還是 String 的參考，如果要 比較的內容是 String 則須使用 equals 方法

在靜態檢查時，兩個物件必須要有繼承關係（而且是同一繼承分支上）才可以使用 instanceof 運算子，否則不用編譯也不會通過

即便是同個父類的 2 個子類，也不在同一個繼承分之上

繼承關係如下：

class Fruit { }

class Apple extends Fruit { }

class Banana extends Fruit { }

靜態語言撰寫，測試

public void staticLangInstanceOfCheck_1() {
    Banana banana = new Banana();

    // 不合法！直接編譯不過
    System.out.println(banana instanceof Animal);
}

判斷的是 左值是否是右值的派生類（左值是否是右值的繼承類）

public void runtimeInstanceOfCheck() {
    Banana banana = new Banana();

    System.out.println(banana instanceof Fruit);
}

● 向上轉型：所謂的向上轉型是 子類別直接、間接賦值給父類別；而 Java 的向上轉形式自動的

public void upperCast() {
    Banana banana = new Banana();
    Fruit fruit = banana;

    System.out.println(fruit);
}

● 向下轉型：所謂的向下轉型是 父類別直接、間接賦予給子類型；必須 強制 轉型

public void downCast() {
    Fruit fruit = new Fruit();
    Banana banana = (Banana) fruit;

    System.out.println(banana);
}

● 只有抽象類別可以有抽象方法，一般類別不能有抽象方法

abstract class AbstractClz {

    // Valid
    abstract void showMsg();

}

● abstract 方法可以有非抽象的建構方法

abstract class AbstractClz {

    abstract void showMsg();

    // Valid
    void sayHello() {
        System.out.println("Hello");
    }

}

● abstract 不可以用來描述建構函數

class MyClz {

    // Invalid
    abstract MyClz() {

    }

}

● 抽象類、抽象方法不可以使用 fainl 描述

// Invalid

final abstract class AbstractClz {

    // Invalid
    final abstract void showMsg();

    void sayHello() {
        System.out.println("Hello");
    }

}

A. JVM 載入類別時就會執行 static 程式碼（包括 static 變數、static 區塊）

class MyClz2 {

    // static 變數
    public static int value = 10;

    // static 區塊
    static {
        Map<String, String> staticMap = new HashMap<>();
        List<String> strList = new ArrayList<>();
    }

}

static 區塊會按照順序做加載

B. JVM 只會與為靜態變數分配一次記憶體（也就是只會被執行一次）

C. 靜態變數在 JVM 記憶體分配策略中大多 分配在 方法區（有些也會放置在堆區）

● 既然不能存取實例，也就 不能使用 this、super 關鍵字

static void cannotUseThis() {
    System.out.println("instance: " + this);
}

static void cannotUseSuper() {
    System.out.println("instance: " + super.toString());
}

● 也就不能 直接存取所屬類別的實體變數、方法

class MyClz3 {

    int value = 10;

    static void showValue() {
        // Invalid
        System.out.println("value: " + value);
    }

}

● 方法（Method）的位元組碼都放在方法區！

不論實體方法、靜態方法，它們的位元組碼都放置在方法區（跟是否事實例化無關，純粹是方法的原始編譯碼放在方法區）