在Java方法調用的過程中，JVM是如何知道調用的是哪個類的方法源代碼？ 這裡面到底有什麼内幕呢？ 這篇文章我們就将揭露JVM方法調用的靜态(static binding) 和動态綁定機制(auto binding) 。
★ 靜态綁定機制
Java代碼
- //被調用的類
- package hr.test;
- class Father{
- public static void f1(){
- System.out.println("Father— f1()");
- }
- }
- //調用靜态方法
- import hr.test.Father;
- public class StaticCall{
- public static void main(){
- Father.f1(); //調用靜态方法
- }
- }
上面的源代碼中執行方法調用的語句(Father.f1())被編譯器編譯成了一條指令：invokestatic #13。我們看看JVM是如何處理這條指令的
(1) 指令中的#13指的是StaticCall類的常量池中第13個常量表的索引項(關于常量池詳見《Class檔案内容及常量池 》)。這個常量表(CONSTATN_Methodref_info ) 記錄的是方法f1資訊的符号引用(包括f1所在的類名，方法名和傳回類型)。JVM會首先根據這個符号引用找到方法f1所在的類的全限定名: hr.test.Father。
(2) 緊接着JVM會加載、連結和初始化Father類。
(3) 然後在Father類所在的方法區中找到f1()方法的直接位址，并将這個直接位址記錄到StaticCall類的常量池索引為13的常量表中。這個過程叫常量池解析 ，以後再次調用Father.f1()時，将直接找到f1方法的位元組碼。
(4) 完成了StaticCall類常量池索引項13的常量表的解析之後，JVM就可以調用f1()方法，并開始解釋執行f1()方法中的指令了。
通過上面的過程，我們發現經過常量池解析之後，JVM就能夠确定要調用的f1()方法具體在記憶體的什麼位置上了。實際上，這個資訊在編譯階段就已經在StaticCall類的常量池中記錄了下來。這種在編譯階段就能夠确定調用哪個方法的方式，我們叫做 靜态綁定機制 。
除了被static 修飾的靜态方法，所有被private 修飾的私有方法、被final 修飾的禁止子類覆寫的方法都會被編譯成invokestatic指令。另外所有類的初始化方法<init>和<clinit>會被編譯成invokespecial指令。JVM會采用靜态綁定機制來順利的調用這些方法。
★ 動态綁定機制
Java代碼
- package hr.test;
- //被調用的父類
- class Father{
- public void f1(){
- System.out.println("father-f1()");
- }
- public void f1(int i){
- System.out.println("father-f1() para-int "+i);
- }
- }
- //被調用的子類
- class Son extends Father{
- public void f1(){ //覆寫父類的方法
- System.out.println("Son-f1()");
- }
- public void f1(char c){
- System.out.println("Son-s1() para-char "+c);
- }
- }
- //調用方法
- import hr.test.*;
- public class AutoCall{
- public static void main(String[] args){
- Father father=new Son(); //多态
- father.f1(); //列印結果： Son-f1()
- }
- }
上面的源代碼中有三個重要的概念：多态(polymorphism) 、方法覆寫 、方法重載 。列印的結果大家也都比較清楚，但是JVM是如何知道f.f1()調用的是子類Sun中方法而不是Father中的方法呢？在解釋這個問題之前，我們首先簡單的講下JVM管理的一個非常重要的資料結構——方法表 。
在JVM加載類的同時，會在方法區中為這個類存放很多資訊(詳見《Java 虛拟機體系結構 》)。其中就有一個資料結構叫方法表。它以數組的形式記錄了目前類及其所有超類的可見方法位元組碼在記憶體中的直接位址 。下圖是上面源代碼中Father和Sun類在方法區中的方法表：
上圖中的方法表有兩個特點：(1) 子類方法表中繼承了父類的方法，比如Father extends Object。 (2) 相同的方法(相同的方法簽名：方法名和參數清單)在所有類的方法表中的索引相同。比如Father方法表中的f1()和Son方法表中的f1()都位于各自方法表的第11項中。
對于上面的源代碼，編譯器首先會把main方法編譯成下面的位元組碼指令：
多态調用的位元組碼指令代碼
- 0 new hr.test.Son [13] //在堆中開辟一個Son對象的記憶體空間，并将對象引用壓入操作數棧
- 3 dup
- 4 invokespecial #7 [15] // 調用初始化方法來初始化堆中的Son對象
- 7 astore_1 //彈出操作數棧的Son對象引用壓入局部變量1中
- 8 aload_1 //取出局部變量1中的對象引用壓入操作數棧
- 9 invokevirtual #15 //調用f1()方法
- 12 return
其中invokevirtual指令的詳細調用過程是這樣的：
(1) invokevirtual指令中的#15指的是AutoCall類的常量池中第15個常量表的索引項。這個常量表(CONSTATN_Methodref_info ) 記錄的是方法f1資訊的符号引用(包括f1所在的類名，方法名和傳回類型)。JVM會首先根據這個符号引用找到調用方法f1的類的全限定名: hr.test.Father。這是因為調用方法f1的類的對象father聲明為Father類型。
(2) 在Father類型的方法表中查找方法f1，如果找到，則将方法f1在方法表中的索引項11(如上圖)記錄到AutoCall類的常量池中第15個常量表中(常量池解析 )。這裡有一點要注意：如果Father類型方法表中沒有方法f1，那麼即使Son類型中方法表有，編譯的時候也通過不了。因為調用方法f1的類的對象father的聲明為Father類型。
(3) 在調用invokevirtual指令前有一個aload_1指令，它會将開始建立在堆中的Son對象的引用壓入操作數棧。然後invokevirtual指令會根據這個Son對象的引用首先找到堆中的Son對象，然後進一步找到Son對象所屬類型的方法表。過程如下圖所示：
(4) 這是通過第(2)步中解析完成的#15常量表中的方法表的索引項11，可以定位到Son類型方法表中的方法f1()，然後通過直接位址找到該方法位元組碼所在的記憶體空間。
很明顯，根據對象(father)的聲明類型(Father)還不能夠确定調用方法f1的位置，必須根據father在堆中實際建立的對象類型Son來确定f1方法所在的位置。這種在程式運作過程中，通過動态建立的對象的方法表來定位方法的方式，我們叫做 動态綁定機制 。
上面的過程很清楚的反映出在方法覆寫的多态調用的情況下，JVM是如何定位到準确的方法的。但是下面的調用方法JVM是如何定位的呢？(仍然使用上面代碼中的Father和Son類型)
Java代碼
- public class AutoCall{
- public static void main(String[] args){
- Father father=new Son();
- char c='a';
- father.f1(c); //列印結果：father-f1() para-int 97
- }
- }
問題是Fahter類型中并沒有方法簽名為f1(char)的方法呀。但列印結果顯示JVM調用了Father類型中的f1(int)方法，并沒有調用到Son類型中的f1(char)方法。
根據上面詳細闡述的調用過程，首先可以明确的是：JVM首先是根據對象father聲明的類型Father來解析常量池的(也就是用Father方法表中的索引項來代替常量池中的符号引用)。如果Father中沒有比對到"合适" 的方法，就無法進行常量池解析，這在編譯階段就通過不了。
那麼什麼叫"合适"的方法呢？當然，方法簽名完全一樣的方法自然是合适的。但是如果方法中的參數類型在聲明的類型中并不能找到呢？比如上面的代碼中調用father.f1(char)，Father類型并沒有f1(char)的方法簽名。實際上，JVM會找到一種“湊合”的辦法，就是通過 參數的自動轉型 來找 到“合适”的 方法。比如char可以通過自動轉型成int，那麼Father類中就可以比對到這個方法了 (關于Java的自動轉型問題可以參見《【解惑】Java類型間的轉型》)。但是還有一個問題，如果通過自動轉型發現可以“湊合”出兩個方法的話怎麼辦？比如下面的代碼：
Java代碼
- class Father{
- public void f1(Object o){
- System.out.println("Object");
- }
- public void f1(double[] d){
- System.out.println("double[]");
- }
- }
- public class Demo{
- public static void main(String[] args) {
- new Father().f1(null); //列印結果： double[]
- }
- }
null可以引用于任何的引用類型，那麼JVM如何确定“合适”的方法呢。一個很重要的标準就是：如果一個方法可以接受傳遞給另一個方法的任何參數，那麼第一個方法就相對不合适。比如上面的代碼: 任何傳遞給f1(double[])方法的參數都可以傳遞給f1(Object)方法，而反之卻不行，那麼f1(double[])方法就更合适。是以JVM就會調用這個更合适的方法。
★ 總結
(1) 所有私有方法、靜态方法、構造器及初始化方法<clinit>都是采用靜态綁定機制。在編譯器階段就已經指明了調用方法在常量池中的符号引用，JVM運作的時候隻需要進行一次常量池解析即可。
(2) 類對象方法的調用必須在運作過程中采用動态綁定機制。
首先，根據對象的聲明類型(對象引用的類型)找到“合适”的方法。具體步驟如下：
① 如果能在聲明類型中比對到方法簽名完全一樣(參數類型一緻)的方法，那麼這個方法是最合适的。
② 在第①條不能滿足的情況下，尋找可以“湊合”的方法。标準就是通過将參數類型進行自動轉型之後再進行比對。如果比對到多個自動轉型後的方法簽名f(A)和f(B)，則用下面的标準來确定合适的方法：傳遞給f(A)方法的參數都可以傳遞給f(B)，則f(A)最合适。反之f(B)最合适 。
③ 如果仍然在聲明類型中找不到“合适”的方法，則編譯階段就無法通過。
然後，根據在堆中建立對象的實際類型找到對應的方法表，從中确定具體的方法在記憶體中的位置。
★ 覆寫（override）
一個執行個體方法可以覆寫（override）在其超類中可通路到的具有相同簽名的所有執行個體方法，進而使能了動态分派（dynamic dispatch）；換句話說，VM将基于執行個體的運作期類型來選擇要調用的覆寫方法。覆寫是面向對象程式設計技術的基礎，并且是唯一沒有被普遍勸阻的名字重用形式：
Java代碼
- class Base{
- public void f(){}
- }
- class Derived extends Base{
- public void f(){}
- }
★ 隐藏（hide）
一個域、靜态方法或成員類型可以分别隐藏（hide）在其超類中可通路到的具有相同名字（對方法而言就是相同的方法簽名)的所有域、靜态方法或成員類型。隐藏一個成員将阻止其被繼承。
Java代碼
- class Base{
- public static void f(){}
- }
- class Derived extends Base {
- private static void f(){} //hides Base. f()
- }
★ 重載（overload）
在某個類中的方法可以重載（overload）另一個方法，隻要它們具有相同的名字和不同的簽名。由調用所指定的重載方法是在編譯期標明的。
Java代碼
- class CircuitBreaker{
- public void f (int i){} //int overloading
- public void f(String s){} //String overloading
- }
★ 遮蔽（shadow）
一個變量、方法或類型可以分别遮蔽（shadow）在一個閉合的文本範圍内的具有相同名字的所有變量、方法或類型。如果一個實體被遮蔽了，那麼你用它的簡單名是無法引用到它的;根據實體的不同，有時你根本就無法引用到它。
Java代碼
- class WhoKnows{
- static String sentence=”I don't know.”;
- public static void main(String[] args〕{
- String sentence=”I don't know.”; //shadows static field
- System.out. println (sentence); // prints local variable
- }
- }
盡管遮蔽通常是被勸阻的，但是有一種通用的慣用法确實涉及遮蔽。構造器經常将來自其所在類的某個域名重用為一個參數，以傳遞這個命名域的值。這種慣用法并不是沒有風險，但是大多數Java程式員都認為這種風格帶來的實惠要超過
其風險:
Java代碼
- class Belt{
- private find int size ; //Parameter shadows Belt. size
- public Belt (int size){
- this. size=size;
- }
- }
★ 遮掩（obscure）
一個變量可以遮掩具有相同名字的一個類型，隻要它們都在同一個範圍内:如果這個名字被用于變量與類型都被許可的範圍，那麼它将引用到變量上。相似地，一個變量或一個類型可以遮掩一個包。遮掩是唯一一種兩個名字位于不同的名字空間的名字重用形式，這些名字空間包括:變量、包、方法或類型。如果一個類型或一個包被遮掩了，那麼你不能通過其簡單
名引用到它，除非是在這樣一個上下文環境中，即文法隻允許在其名字空間中出現一種名字。遵守命名習慣就可以極大地消除産生遮掩的可能性:
Java代碼
- public class Obscure{
- static String System;// Obscures type java.lang.System
- public static void main(String[] args)
- // Next line won't compile:System refers to static field
- System. out. println(“hello, obscure world!”);
- }
- }