緣起


我在看Spring的原始碼時，發現了一個隱藏的問題，就是父類方法（Method）在子類例項上的反射（Reflect）呼叫。

初次看到，感覺有些奇特，因為父類方法可能是抽象的或私有的，但我沒有去懷疑什麼，這可是Spring的原始碼，肯定不會有錯。

不過我去做了測試，發現確實是正確的，那一瞬間竟然給我了一絲的驚豔。

這其實是面向物件（繼承與重寫，即多型）和反射結合的產物。下面先來看測試，最後再進行總結。

友情提示：測試內容較多，不過還是值得一看。


具體方法的繼承與重寫


先準備一個父類，有三個方法，分別是public，protected，private。

public class Parent {
 

    public String m1() {
        return "Parent.m1";
    }

    protected String m2() {
        return "Parent.m2";
    }
 

    private String m3() {
        return "Parent.m3";
    }
}

再準備一個子類，繼承上面的父類，也有三個相同的方法。

public class Child extends Parent {

    @Override
    public String m1() {
 
        return "Child.m1";
    }

    @Override
    protected String m2() {
        return "Child.m2";
    }

    private String m3() {
        return "Child.m3";
    }
}

public和protected是對父類方法的重寫，private自然不能重寫。

首先，通過反射獲取父類和子類的方法m1，並輸出：

Method pm1 = Parent.class.getDeclaredMethod("m1");
Method cm1 = Child.class.getDeclaredMethod("m1");

Log.log(pm1);
Log.log(cm1);

輸出如下：

public java.lang.String org.cnt.java.reflect.method.Parent.m1()
public java.lang.String org.cnt.java.reflect.method.Child.m1()

可以看到，一個是父類的方法，一個是子類的方法。

其次，比較下這兩個方法是否相同或相等：

Log.log("pm1 == cm1 -> {}", pm1 == cm1);
Log.log("pm1.equals(cm1) -> {}", pm1.equals(cm1));

輸入如下：

pm1 == cm1 -> false
pm1.equals(cm1) -> false

它們既不相同也不相等，因為一個在父類裡，一個在子類裡，它們各有各的原始碼，互相獨立。

然後，例項化父類和子類物件：

Parent p = new Parent();
Child c = new Child();

接著，父類方法分別在父類和子類物件上反射呼叫：

Log.log(pm1.invoke(p));
Log.log(pm1.invoke(c));

輸出如下：

Parent.m1
Child.m1

父類方法在父類物件上反射呼叫輸出Parent.m1，這很好理解。

父類方法在子類物件上反射呼叫輸出Child.m1，初次看到的話，還是有一些新鮮的。

明明呼叫的是父類版本的Method，輸出的卻是子類重寫版本的結果。

然後，子類方法分別在父類和子類物件上反射呼叫：

Log.log(cm1.invoke(p));
Log.log(cm1.invoke(c));

輸出如下：

IllegalArgumentException
Child.m1

子類方法在父類物件上反射呼叫時報錯。

子類方法在子類物件上反射呼叫時輸出Child.m1，這很好理解


按照同樣的方式，對方法m2進行測試，得到的結果和m1一樣。

它們一個是public的，一個是protected的，對於繼承與重寫來說是一樣的。

然後再對方法m3進行測試，它是private的，看看會有什麼不同。

首先，父類方法分別在父類和子類物件上反射呼叫：

Log.log(pm3.invoke(p));
Log.log(pm3.invoke(c));

輸入如下：

Parent.m3
Parent.m3

可以看到，輸出的都是父類裡的內容，和上面確實有所不同。

其次，子類方法分別在父類和子類物件上反射呼叫：

Log.log(cm3.invoke(p));
Log.log(cm3.invoke(c));

輸出如下：

IllegalArgumentException
Child.m3

子類方法在父類物件上反射呼叫時報錯。

子類方法在子類物件上反射呼叫時輸出Child.m3。


抽象方法的繼承與重寫


再大膽一點，使用抽象方法來測試下。

先準備一個抽象父類，有兩個抽象方法。

public abstract class Parent2 {

    public abstract String m1();

    protected abstract String m2();
}

再準備一個子類，繼承這個父類，並重寫抽象方法。

public class Child2 extends Parent2 {

    @Override
    public String m1() {
        return "Child2.m1";
    }

    @Override
    protected String m2() {
        return "Child2.m2";
    }
}

使用反射分別獲取父類和子類的方法m1，並輸出下：

public abstract java.lang.String org.cnt.java.reflect.method.Parent2.m1()
public java.lang.String org.cnt.java.reflect.method.Child2.m1()

pm1 == cm1 -> false
pm1.equals(cm1) -> false

可以看到父類方法是抽象的，子類重寫後變為非抽象的，這兩個方法既不相同也不相等。

由於父類是抽象類，不能例項化，因此只能在子類物件上反射呼叫這兩個方法：

Log.log(pm1.invoke(c2));
Log.log(cm1.invoke(c2));

輸出如下：

Child2.m1
Child2.m1

沒有報錯。且輸出正常，是不是又有一絲新鮮感，抽象方法也可以被反射呼叫。

對方法m2進行測試，得到相同的結果，因為protected和public對於繼承與重寫的規則是一樣的。


介面方法的實現與繼承


膽子漸漸大起來，再用介面來試試。

準備一個介面，包含抽象方法，預設方法和靜態方法。

public interface Inter {

    String m1();

    default String m2() {
        return "Inter.m2";
    }

    default String m3() {
        return "Inter.m3";
    }

    static String m4() {
        return "Inter.m4";
    }
}

準備一個實現類，實現這個介面，實現方法m1，重寫方法m2。

public class Impl implements Inter {

    @Override
    public String m1() {
        return "Impl.m1";
    }

    @Override
    public String m2() {
        return "Impl.m2";
    }

    public static String m5() {
        return "Impl.m5";
    }
}

分別從介面和實現類獲取方法m1，並輸出：

public abstract java.lang.String org.cnt.java.reflect.method.Inter.m1()
public java.lang.String org.cnt.java.reflect.method.Impl.m1()

im1 == cm1 -> false
im1.equals(cm1) -> false

可以看到介面中的方法是抽象的。因為它沒有方法體。

因為介面不能例項化，所以這兩個方法只能在實現類上反射呼叫：

Impl c = new Impl();

Log.log(im1.invoke(c));
Log.log(cm1.invoke(c));

輸出如下：

Impl.m1
Impl.m1

沒有報錯，輸出正常，又一絲的新鮮，接口裡的方法也可以通過反射呼叫。

對m2進行測試，m2是介面的預設方法，且被實現類重新實現了。

輸出下介面中的m2和實現類中的m2，如下：

public default java.lang.String org.cnt.java.reflect.method.Inter.m2()
public java.lang.String org.cnt.java.reflect.method.Impl.m2()

im2 == cm2 -> false
im2.equals(cm2) -> false

這兩個方法既不相同也不相等。

把它們分別在實現類上反射呼叫：

Impl c = new Impl();

Log.log(im2.invoke(c));
Log.log(cm2.invoke(c));

輸出如下：

Impl.m2
Impl.m2

因為實現類重寫了介面預設方法，所以輸出的都是重寫後的內容。

對m3進行測試，m3也是介面的預設方法，不過實現類沒有重新實現它，而是選擇使用介面的預設實現。

同樣從介面和實現類分別獲取這個方法，並輸出：

public default java.lang.String org.cnt.java.reflect.method.Inter.m3()
public default java.lang.String org.cnt.java.reflect.method.Inter.m3()

im3 == cm3 -> false
im3.equals(cm3) -> true

發現輸出的都是介面的方法，它們雖然不相同（same），但是卻相等（equal）。因為實現類只是簡單的繼承，並沒有重寫。

這兩個方法都在實現類的物件上反射呼叫，輸出如下：

相關推薦