我們看一下main方法的位元組碼，可知say1方法是static方法，所有它的方法呼叫指令為invokestatic，再者他是一個靜態解析過程，我們可以從位元組碼清除地看出來

StaticResolution.say1 ()字樣。

say2()是一個final方法，不可以過載，重寫，雖然是一個invokevirtual方法但是他也是靜態解析的。

say3()也是invokevirtual方法，但也是靜態解析的。

say3(int i)是say3()的一個過載方法，但是過載是在編譯期就確定到底要呼叫哪個方法，所以也是靜態解析。

分派（Dispatch）

分派有靜態分派與動態分派之分。 靜態分派：先看一下程式碼

public class StaticDispatch {

	static abstract class Human {
	}

	static class Man extends Human {
	}

	static class Woman extends Human {
	}

	public void sayHello(Human guy) {
		System.out.println("hello,guy!");
	}

	public void <span style="color:#ff0000;">sayHello(Man guy)</span> {
		System.out.println("hello,gentleman!");
	}

	public void <span style="color:#ff0000;">sayHello(Woman guy)</span> {
		System.out.println("hello,lady!");
	}

	public static void main(String[] args) {
		Human man = new Man();
		Human woman = new Woman();
		StaticDispatch sr = new StaticDispatch();
		sr.sayHello(man);
		sr.sayHello(woman);
	}
}
 

我們注意到兩個sayHello方法的引數型別分別是Man和Woman，都繼承自Human。 我們看一下main方法的bytecode.

public static main(String[]) : void
   L0
    LINENUMBER 32 L0
    NEW StaticDispatch$Man
    DUP
    INVOKESPECIAL StaticDispatch$Man.<init> () : void
    ASTORE 1
   L1
    LINENUMBER 33 L1
    NEW StaticDispatch$Woman
    DUP
    INVOKESPECIAL StaticDispatch$Woman.<init> () : void
    ASTORE 2
   L2
    LINENUMBER 34 L2
    NEW StaticDispatch
    DUP
    INVOKESPECIAL StaticDispatch.<init> () : void
    ASTORE 3
  <span style="color:#ff0000;"> L3
    LINENUMBER 35 L3
    ALOAD 3: sr
    ALOAD 1: man
    INVOKEVIRTUAL StaticDispatch.sayHello (StaticDispatch$Human) : void
   L4
    LINENUMBER 36 L4
    ALOAD 3: sr
    ALOAD 2: woman
    INVOKEVIRTUAL StaticDispatch.sayHello (StaticDispatch$Human) : void</span>
   L5
    LINENUMBER 37 L5
    RETURN
   L6
    LOCALVARIABLE args String[] L0 L6 0
    LOCALVARIABLE man StaticDispatch$Human L1 L6 1
    LOCALVARIABLE woman StaticDispatch$Human L2 L6 2
    LOCALVARIABLE sr StaticDispatch L3 L6 3
    MAXSTACK = 2
    MAXLOCALS = 4
 

對於型如Human man=new Man（）；其中Human我們稱之為靜態型別，Man我們稱之為實際型別。靜態型別在編譯期就確定了，而實際型別要到執行時才能真正地知道是什麼型別。

對於方法過載，由於方法過載是在編譯器就確定到底TMD要呼叫哪個方法，所以過載方法的引數確定，就必須由引數的靜態型別（加入引數是物件型別）來確定的。

所以TMD兩個sayHello方法都會變成這樣

StaticDispatch.sayHello (StaticDispatch$Human)我們注意到為靜態分派，且引數的型別變為Human即靜態型別。

動態分派

動態分派一般對應Java多型的重寫（override）。 我們先看一段程式碼先。

/**
 * 方法動態分派演示
 * @author cxt
 */
public class DynamicDispatch {

	static abstract class Human {
		protected abstract void sayHello();
	}

	static class Man extends Human {
		@Override
		protected void sayHello() {
			System.out.println("man say hello");
		}
	}

	static class Woman extends Human {
		@Override
		protected void sayHello() {
			System.out.println("woman say hello");
		}
	}

	public static void main(String[] args) {
		<span style="color:#ff0000;">Human man = new Man();
		Human woman = new Woman();
		man.sayHello();
		woman.sayHello();
		man = new Woman();
		man.sayHello();</span>
	}
}
 

mian方法對應的bytecode位：

public static main(String[]) : void
   L0
    LINENUMBER 28 L0
    NEW DynamicDispatch$Man
    DUP
    INVOKESPECIAL DynamicDispatch$Man.<init> () : void
    ASTORE 1
   L1
    LINENUMBER 29 L1
    NEW DynamicDispatch$Woman
    DUP
    INVOKESPECIAL DynamicDispatch$Woman.<init> () : void
    ASTORE 2
  <span style="color:#ff0000;"> L2
    LINENUMBER 30 L2
    ALOAD 1: man
    INVOKEVIRTUAL DynamicDispatch$Human.sayHello () : void</span>
   <span style="color:#ff0000;">L3
    LINENUMBER 31 L3
    ALOAD 2: woman
    INVOKEVIRTUAL DynamicDispatch$Human.sayHello () : void</span>
   L4
    LINENUMBER 32 L4
    NEW DynamicDispatch$Woman
    DUP
    INVOKESPECIAL DynamicDispatch$Woman.<init> () : void
    ASTORE 1: man
   <span style="color:#ff0000;">L5
    LINENUMBER 33 L5
    ALOAD 1: man
    INVOKEVIRTUAL DynamicDispatch$Human.sayHello () : void</span>
   L6
    LINENUMBER 34 L6
    RETURN
   L7
    LOCALVARIABLE args String[] L0 L7 0
    LOCALVARIABLE man DynamicDispatch$Human L1 L7 1
    LOCALVARIABLE woman DynamicDispatch$Human L2 L7 2
    MAXSTACK = 2
    MAXLOCALS = 3

我們注意到sayHello是一個重寫方法，且呼叫此方法的命令都是invokevirtual DynamicDispatch，也就是動態分派的，動態分派會在執行時，確定物件的實際型別，然後再確定要去呼叫哪個方法，這是Java最重要的一個特性。

我們看一些 invokevirtual指令的多型執行過程。

invokevirtual指令的多型查詢過程開始說起，invokevirtual指令的執行時解析過程大致分為以下幾個步驟：
1）找到運算元棧頂的第一個元素所指向的物件的實際型別，記作C。
2）如果在型別C中找到與常量中的描述符和簡單名稱都相符的方法，則進行訪問許可權校驗，如果通過則返回這
個方法的直接引用，查詢過程結束；如果不通過，則返回java.lang.IllegalAccessError異常。
3）否則，按照繼承關係從下往上依次對C的各個父類進行第2步的搜尋和驗證過程。
4）如果始終沒有找到合適的方法，則丟擲java.lang.AbstractMethodError異常。

單分派與多分派

/**
 * 單分派、多分派演示
* @author cxt
 */
public class Dispatch {

	static class QQ {}

	static class _360 {}

	public static class Father {
		public void hardChoice(QQ arg) {
			System.out.println("father choose qq");
		}

		public void hardChoice(_360 arg) {
			System.out.println("father choose 360");
		}
	}

	public static class Son extends Father {
		public void hardChoice(QQ arg) {
			System.out.println("son choose qq");
		}

		public void hardChoice(_360 arg) {
			System.out.println("son choose 360");
		}
	}

	public static void main(String[] args) {
		Father father = new Father();
		Father son = new Son();
		father.hardChoice(new _360());
		son.hardChoice(new QQ());
	}
}

執行結果為：

father choose 360
son choose qq

bytecode：

public static main(String[]) : void
   L0
    LINENUMBER 34 L0
    NEW Dispatch$Father
    DUP
    INVOKESPECIAL Dispatch$Father.<init> () : void
    ASTORE 1
   L1
    LINENUMBER 35 L1
    NEW Dispatch$Son
    DUP
    INVOKESPECIAL Dispatch$Son.<init> () : void
    ASTORE 2
   <span style="color:#ff0000;">L2
    LINENUMBER 36 L2
    ALOAD 1: father
    NEW Dispatch$_360
    DUP
    INVOKESPECIAL Dispatch$_360.<init> () : void
    INVOKEVIRTUAL Dispatch$Father.hardChoice (Dispatch$_360) : void</span>
  <span style="color:#ff0000;"> L3
    LINENUMBER 37 L3
    ALOAD 2: son
    NEW Dispatch$QQ
    DUP
    INVOKESPECIAL Dispatch$QQ.<init> () : void
    INVOKEVIRTUAL Dispatch$Father.hardChoice (Dispatch$QQ) : void</span>
   L4
    LINENUMBER 38 L4
    RETURN
   L5
    LOCALVARIABLE args String[] L0 L5 0
    LOCALVARIABLE father Dispatch$Father L1 L5 1
    LOCALVARIABLE son Dispatch$Father L2 L5 2
    MAXSTACK = 3
    MAXLOCALS = 3

fahter.hardChioce(XX)方法到底要呼叫那個是在編譯期間確定的，過載嘛（靜態分派），由於有兩個選擇到底ＴＭＤ的是ＱＱ還是360或者其他都在編譯期間就確定了。因為有多個宗量（可以理解為引數型別的個數）的選擇，所以Java是屬於一種靜態多宗量分派語言。 而在執行時，son.hardChoice(XXXX),唯一確定的就是son到底是什麼型別，執行時發現原來是Son型別，所以就會呼叫Son的hardchoice(XXX),至於方法的引數是什麼，JVM就沒有在執行時再去確定，因為已經在編譯期間已經確定是什麼引數了，所以執行時只是考慮到底實際型別是什麼，要呼叫實際型別的哪一個方法。 所以我們可以知道其實Java就是一種動態單宗量分派語言。（據說C#已經支援動態多宗量分派了）。 參考自周志明的《深入理解Java虛擬機器》 （完）