基本概念
绑定，指的是一个方法的调用与其所在的类关联起来。
绑定可分为静态绑定和动态绑定。
在分析静态绑定和动态绑定之前需要知道的几个概念：
-
编译期：编译过程是将 Java 源文件编译成字节码（.class文件，JVM 可执行代码）的过程，在这个过程中Java是不与内存打交道的，在这个过程中编译器会进行语法的分析，如果语法不正确就会报错。
立即学习“Java免费学习笔记（深入）”；
运行期：运行过程是指JVM（Java虚拟机）装载字节码文件并解释执行，在这个过程才是真正的创建内存，执行Java程序。
方法调用
Java 的方法调用过程如下：
编辑器查看对象的声明类型和方法名。获取所有可能被调用的候选方法，因为在方法重载的情况。例如：方法一为 print(String str)、方法二为 print(int )。
编译器查看调用方法的入参类型。从候选方法中挑选匹配的方法。例如入参为 “hello”，则挑选 print(String str)。
若方法是 private、static、final 修饰或者构造函数，编译器就可以确定调用哪个方法。这是静态绑定。
如果不是上述情况，就要使用运行时（动态）绑定。
静态绑定
静态绑定，又称前期绑定，编译时绑定。表示编译期进行的绑定，即程序运行前方法已被绑定。
只有被 final，static，private 修饰的方法、成员变量、构造方法是静态绑定：
| 类型 | 解释 |
|---|---|
| final | 被其修饰的方法可以被继承，但不能被重写；子类对象可以调用，但是调用的是父类中定义的那个方法；间接表明将方法声明为 final 可以避免重写，关闭动态绑定。 |
| private | 被其修饰地方法隐式地包含了 final 关键字。由于它对外是不可见的，所以不能被继承，重写；只能通过类自身的对象来调用，因此在方法运行之前就可以明确对象。 |
| static | 静态方法是依赖于类而依赖于对象的。它可以被子类继承（实质是被子类隐藏），但是不能被子类重写。当子类对象向上转型为父类对象时，不论子类中有没有定义这个静态方法，该对象都会使用父类中的静态方法。因此这里说静态方法可以被隐藏。 |
| 成员变量 | 默认 Java 对属性采用静态绑定，这样在编译期就能发现程序错误，能够提供效率。 |
| 构造方法 | 构造方法不能被继承的，子类继承父类时默认要先调用父类的构造方法（无论显示或隐式）。因此在程序运行之前就可以知道构造方法术语哪个对象。 |
来看下面的这个例子：
// 父类class Parent{ // 变量
String name="Parent"; // 静态方法
static void print(){
System.out.println("Parent print");
} // 私有方法
private void say(){
System.out.println("Parent say");
} // 终态方法
final void look(){
System.out.println("Parent look");
}
}// 子类class Son extends Parent{
String name ="Son"; static void print(){
System.out.println("Son print");
} // 编译错误，无法重写父类的 final方法
final void look(){};
}public class Test{
public static void main(String[] args) { // 发生向上转型
Parent p = new Son(); // 输出 Parent
System.out.println(p.name); // 输出 Parent print
p.print(); // 编译错误，对外不可见
p.say();
}
}动态绑定
动态绑定，又称后期绑定，运行时绑定；表示在运行时根据具体对象的类型进行绑定。
动态绑定的过程：
虚拟机提取对象的实际类型的方法表；
虚拟机搜索方法签名；
调用方法。
下面来看一个例子：
class A { int x = 5;
}
class B extends A { int x = 6;
}
class Parent { public A getValue() {
System.out.print("Parent Method "); return new A();
}
}
class Son extends Parent { public B getValue() {
System.out.print("Son Method "); return new B();
}
}public class Test {
public static void main(String[] args) { // 向上转型
Parent p = new Son(); // 输出结果：Son Method 5
// 注意：是 5 不是 6 ！
System.out.println(p.getValue().x);
}
}观察输出分析如下：
p.getValue( ) ，由于发生了向上转型，因此它有先从子类（Son）查找该方法，此时调用的是 Son 的方法。这里属于动态绑定。
p.getValue( ).x，由于 x 属于成员变量，因此在程序运行之前就确定了它的对象（属于Parent），这里是发生了静态绑定。
如果还不明白，再来看一个例子：
class Parent {
String name = "Parent " + this.getClass().getName();
}
class Son extends Parent {
String name = "Son" + this.getClass().getName();
}public class Test {
public static void main(String[] args) { // 向上转型
Parent p = new Son(); // 输出：Parent Son
System.out.println(p.name);
}
}观察输出结果分析如下：
p.name ：name 是成员变量，此时发生静态绑定，因此调用的是 Parent 的属性。
this.getClass( )：getClass 是方法，由于此时发生了向上转型，默认程序会从子类开始查找该方法，正好子类也存在该方法。因此调用的是子类的方法，此时发生了动态绑定。
以上就是07.Java 基础 - 静态绑定&动态绑定的内容，更多相关内容请关注PHP中文网（www.php.cn）！
