Java如何對方法進行調用詳解

Posted on by

一、方法調用

方法調用的唯一目的:確定要調用哪一個方法

方法調用分為解析調用和分派調用

二、非虛方法與虛方法

非虛方法: 靜態方法,私有方法,父類中的方法,被final修飾的方法,實例構造器

與之對應不是非虛方法的就是虛方法瞭

它們都沒有重寫出其他版本的方法,非常適合在類加載階段就進行解析(符號引用->直接引用)

三、調用指令

普通調用指令

  • invokestatic:調用靜態方法
  • invokespecial:調用私有方法,父類中的方法,實例構造器方法,final方法
  • invokeinterface:調用接口方法
  • invokevirtual: 調用虛方法

使用invokestatic和invokespecial指令的一定是非虛方法

使用invokeinterface指令一定是虛方法(因為接口方法需要具體的實現類去實現)

使用invokevirtual指令的是虛方法

動態調用指令

invokedynamic: 動態解析出需要調用的方法再執行

jdk 7 出現invokedynamic,支持動態語言

測試虛方法代碼

父類

public class Father {
    public static void staticMethod(){
        System.out.println("father static method");
    }

    public final void finalMethod(){
        System.out.println("father final method");
    }

    public Father() {
        System.out.println("father init method");
    }

    public void overrideMethod(){
        System.out.println("father override method");
    }
}

接口

public interface TestInterfaceMethod {
    void testInterfaceMethod();
}

子類

public class Son extends Father{

    public Son() {
        //invokespecial 調用父類init 非虛方法
        super();
        //invokestatic 調用父類靜態方法 非虛方法
        staticMethod();
        //invokespecial 調用子類私有方法 特殊的非虛方法
        privateMethod();
        //invokevirtual 調用子類的重寫方法 虛方法
        overrideMethod();
        //invokespecial 調用父類方法 非虛方法
        super.overrideMethod();
        //invokespecial 調用父類final方法 非虛方法
        super.finalMethod();
        //invokedynamic 動態生成接口的實現類 動態調用
        TestInterfaceMethod test = ()->{
            System.out.println("testInterfaceMethod");
        };
        //invokeinterface 調用接口方法 虛方法
        test.testInterfaceMethod();
    }

    @Override
    public void overrideMethod(){
        System.out.println("son override method");
    }

    private void privateMethod(){
        System.out.println("son private method");
    }

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

註意: 接口中的默認方法也是invokeinterface,接口中的靜態方法是invokestatic

四、解析調用

在編譯就確定瞭要調用哪個方法,運行時不可以改變

解析調用 調用的是 非虛方法

五、分派調用

分派又分為靜態分派與動態分配

早期綁定:解析調用和靜態分派這種編譯期間可以確定調用哪個方法

晚期綁定: 動態分派這種編譯期無法確定,要到運行時才能確定調用哪個方法

六、靜態分派

//  靜態類型      	 實際類型
	List list = new ArrayList();

靜態分派: 根據靜態類型決定方法執行的版本的分派

發生在編譯期,特殊的解析調用

典型的表現就是方法的重載

public class StaticDispatch {
    public void test(List list){
        System.out.println("list");
    }

    public void test(ArrayList arrayList){
        System.out.println("arrayList");
    }

    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        List list = new ArrayList();
        StaticDispatch staticDispatch = new StaticDispatch();
        staticDispatch.test(list);
        staticDispatch.test(arrayList);
    }
}
/*
list
arrayList
*/

方法的版本並不是唯一的,往往隻能確定一個最適合的版本

七、動態分派

動態分派:動態期根據實際類型確定方法執行版本的分派

動態分派與重寫有著緊密的聯系

public class DynamicDispatch {
    public static void main(String[] args) {
        Father father = new Father();
        Father son = new Son();

        father.hello();
        son.hello();
    }
    static class Father{
        public void hello(){
            System.out.println("Father hello");
        }
    }

    static class Son extends Father{
        @Override
        public void hello() {
            System.out.println("Son hello");
        }
    }
}
/*
Father hello
Son hello
*/

雖然常量池中的符號引用相同,invokevirtual指令最終指向的方法卻不一樣

分析invokevirtual指令搞懂它是如何確定調用的方法

1.invokevirtual找到棧頂元素的實際類型

2.如果在這個實際類型中找到與常量池中描述符與簡單名稱相符的方法,並通過訪問權限的驗證就返回這個方法的引用(未通過權限驗證返回IllegalAccessException非法訪問異常)

3.如果在實際類型中未找到,就去實際類型的父類中尋找(沒找到拋出AbstractMethodError異常)

因此,子類重寫父類方法時,根據invokevirtual指令規則,先找實際類型,所以才存在重寫的多態

頻繁的動態分派會重新查找棧頂元素實際類型,會影響執行效率

為提高性能,JVM在該類方法區建立虛方法表使用索引表來代替查找

字段不存在多態

當子類出現與父類相同的字段,子類會覆蓋父類的字段

public class DynamicDispatch {
    public static void main(String[] args) {
        Father son = new Son();
    }
    static class Father{
        int num = 1;

        public Father() {
            hello();
        }

        public void hello(){
            System.out.println("Father hello " + num);
        }
    }

    static class Son extends Father{
        int num = 2;

        public Son() {
            hello();
        }

        @Override
        public void hello() {
            System.out.println("Son hello "+ num);
        }
    }
}
/*
Son hello 0
Son hello 2
*/

先對父類進行初始化,所以會先執行父類中的構造方法,而構造方法去執行瞭hello()方法,此時的實際類型是Son於是會去執行Son的hello方法,此時子類還未初始化成員變量,隻是有個默認值,所以輸出Son hello 0

八、單分派與多分派

public class DynamicDispatch {
    public static void main(String[] args) {
        Father son = new Son();
        Father father = new Father();

        son.hello(new Nod());
        father.hello(new Wave());
    }
    static class Father{


        public void hello(Nod nod){
            System.out.println("Father nod hello " );
        }

        public void hello(Wave wave){
            System.out.println("Father wave hello " );
        }
    }

    static class Son extends Father{

        @Override
        public void hello(Nod nod) {
            System.out.println("Son nod hello");
        }

        @Override
        public void hello(Wave wave) {
            System.out.println("Son wave hello");
        }
    }

    //招手
    static class Wave{}
    //點頭
    static class Nod{}
}
/*
Son nod hello
Father wave hello 
*/

宗量: 方法參數與方法調用者

分派還可以分為單,多分派

單分派:根據一個宗量選擇方法

多分派:根據多個宗量選擇方法

在編譯時,不僅要關心靜態類型是Father還是Son,還要關心參數是Nod還是Wave,所以靜態分派是多分派(根據兩個宗量對方法進行選擇)

在執行son.hello(new Nod())時隻需要關心實際類型是Son還是Father,所以動態分派是單分派(根據一個宗量對方法進行選擇)

到此這篇關於Java如何對方法進行調用詳解的文章就介紹到這瞭,更多相關Java調用方法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：