1、静态链接与动态链接

在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关。

静态链接：
当一个字节码文件被装载进JVM内部时，如果被调用的目标方法在编译期确定，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。

动态链接：
如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用的方法的符号转换为直接引用，由于这种引用转换过程具备动态性，因此也被称之为动态链接。

回到顶部

2、方法的绑定机制

静态链接和动态链接对应的方法的绑定机制为：早期绑定（Early Binding）和晚期绑定（Late Binding）。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这仅仅发生一次。

早期绑定

早期绑定就是指被调用的目标方法如果在编译期可知，且运行期保持不变时，即可将这个方法与所属的类型进行绑定，这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。

晚期绑定
如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法，这种绑定方式也就被称之为晚期绑定。

随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言如今越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是它们彼此之间始终保持着一个共性，那就是都支持封装、继承和多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式。

Java中任何一个普通的方法其实都具备虚函数的特征，它们相当于C++语言中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final来标记这个方法。

 1 /**
 2  * 说明早期绑定和晚期绑定的例子
 3  */
 4 class Animal {
 5     public void eat() {
 6         System.out.println("动物进食");
 7     }
 8 }
 9 
10 interface Huntable {
11     void hunt();
12 }
13 
14 class Dog extends Animal implements Huntable {
15     @Override
16     public void eat() {
17         System.out.println("狗吃骨头");
18     }
19 
20     @Override
21     public void hunt() {
22         System.out.println("捕食耗子，多管闲事");
23     }
24 }
25 
26 class Cat extends Animal implements Huntable {
27     public Cat() {
28         super(); //表现为：早期绑定
29     }
30 
31     public Cat(String name) {
32         this(); //表现为：早期绑定
33     }
34 
35     @Override
36     public void eat() {
37         super.eat(); //表现为：早期绑定
38         System.out.println("猫吃鱼");
39     }
40 
41     @Override
42     public void hunt() {
43         System.out.println("捕食耗子，天经地义");
44     }
45 }
46 
47 public class AnimalTest {
48     public void showAnimal(Animal animal) {
49         animal.eat(); //表现为：晚期绑定
50     }
51 
52     public void showHunt(Huntable h) {
53         h.hunt(); //表现为：晚期绑定
54     }
55 }

回到顶部

3、虚方法和非虚方法

如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的。这样的方法称为非虚方法。
静态方法、私有方法、final 方法、实例构造器、父类方法都是非虚方法。
其他方法称为虚方法。

子类对象的多态性的使用前提

类的继承关系
方法的重写

虚拟机中调用方法的指令

普通调用指令：

invokestatic：调用静态方法，解析阶段确定唯一方法版本
invokespecial：调用<init>方法、私有及父类方法，解析阶段确定唯一方法版本
invokevirtual：调用所有虚方法
invokeinterface：调用接口方法

动态调用指令

invokedynamic：动态解析出需要调用的方法，然后执行

区别：

前四条指令固化在虚拟机内部，方法的调用执行不可人为干预。
而invokedynamic指令则支持由用户确定方法版本。
其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法。

 1 /**
 2  * 解析调用中非虚方法、虚方法的测试
 3  *
 4  * invokestatic指令和invokespecial指令调用的方法称为非虚方法
 5  */
 6 class Father {
 7     public Father() {
 8         System.out.println("father的构造器");
 9     }
10 
11     public static void showStatic(String str) {
12         System.out.println("father " + str);
13     }
14 
15     public final void showFinal() {
16         System.out.println("father show final");
17     }
18 
19     public void showCommon() {
20         System.out.println("father 普通方法");
21     }
22 }
23 
24 public class Son extends Father {
25     public Son() {
26         //invokespecial 非虚方法
27         super();
28     }
29 
30     public Son(int age) {
31         //invokespecial 非虚方法
32         this();
33     }
34 
35     //不是重写的父类的静态方法，因为静态方法不能被重写！
36     public static void showStatic(String str) {
37         System.out.println("son " + str);
38     }
39 
40     private void showPrivate(String str) {
41         System.out.println("son private" + str);
42     }
43 
44     public void show() {
45         //invokestatic 非虚方法
46         showStatic("baidu.com");
47 
48         //invokestatic 非虚方法
49         super.showStatic("good!");
50 
51         //invokespecial 非虚方法
52         showPrivate("hello!");
53 
54         //invokevirtual
55         //虽然字节码指令中显示为invokevirtual，但因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法。
56         showFinal();
57 
58         //invokespecial 非虚方法
59         super.showCommon();
60 
61         //invokevirtual 虚方法
62         //有可能子类会重写父类的showCommon()方法
63         showCommon();
64         
65         //invokevirtual 虚方法
66           //info()是普通方法，有可能被重写，所以是虚方法
67         info();
68 
69         MethodInterface in = null;
70         //invokeinterface 虚方法
71         in.methodA();
72     }
73 
74     public void info() {
75 
76     }
77 
78     public void display(Father f) {
79         f.showCommon();
80     }
81 
82     public static void main(String[] args) {
83         Son so = new Son();
84         so.show();
85     }
86 }
87 
88 interface MethodInterface {
89     void methodA();
90 }

回到顶部

4、关于 invokedynamic 指令

JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进。

但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的 Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。

Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。

动态类型语言和静态类型语言

动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。
说的再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征。

1 Java语言：String info = "mogu blog";             (Java是静态类型语言的，会先编译再进行类型检查)
2 JS语言：var name = "shkstart";  var name = 10;    （运行时才进行检查）
3 Python语言：info = 130.5;  （动态类型语言）

回到顶部