07.Java 基础 - 静态绑定&动态绑定

基本概念

绑定，指的是一个方法的调用与其所在的类关联起来。

绑定可分为静态绑定和动态绑定。

在分析静态绑定和动态绑定之前需要知道的几个概念：

• 编译期：编译过程是将 Java 源文件编译成字节码（.class文件，JVM 可执行代码）的过程，在这个过程中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 = ;
}

class B extends A {
    int x = ;
}

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 是方法，由于此时发生了向上转型，默认程序会从子类开始查找该方法，正好子类也存在该方法。因此调用的是子类的方法，此时发生了动态绑定。

参考

• http://xiaofeng.site/