理解Java中的静态绑定和动态绑定

理解Java中的静态绑定和动态绑定

Java中支持多态，也就是同一个方法可以被不同的对象调用，不同的对象会表现出不同的行为。这种多态性质也分为静态绑定和动态绑定。

静态绑定

静态绑定（Static Binding）也称为早期绑定（Early Binding），是在编译期间进行的绑定。静态绑定是根据引用类型来确定调用哪个方法的。比如下面的代码：

public class Animal {
    public void sayHello() {
        System.out.println("Animal say hello");
    }
}

public class Cat extends Animal {
    @Override
    public void sayHello() {
        System.out.println("Cat say hello");
    }
}

public class Dog extends Animal {
    @Override
    public void sayHello() {
        System.out.println("Dog say hello");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Cat cat = new Cat();
        Dog dog = new Dog();

        animal.sayHello();  // output: Animal say hello
        cat.sayHello();     // output: Cat say hello
        dog.sayHello();     // output: Dog say hello

        Animal animal2 = new Cat();
        animal2.sayHello(); // output: Cat say hello
    }
}

在这个例子中，Animal、Cat和Dog类都重写了sayHello()方法。当我们创建一个Animal、Cat和Dog对象时，它们分别调用自己重写的方法。在引用animal2时，我们创建了一个Animal类型的引用来引用Cat对象，当我们调用animal2的sayHello()方法时，编译器会找到这个引用类型Animal，并根据该类型查找对应的方法。但是我们已经知道animal2实际上是Cat类型的对象，Cat类中也重写了sayHello()方法，此时就发生了静态绑定，因为在编译时编译器就已经确定了调用的方法是Animal类中的sayHello()方法。

动态绑定

动态绑定（Dynamic Binding）也称为晚期绑定（Late Binding），是在运行期间进行的绑定。当调用一个方法时，编译器并不知道方法的实际类型，只有在运行时才能确定方法的实际类型。当一个方法调用被动态绑定时，JVM会在对象的类的方法表中查找该方法的实现。如果没有在当前类中找到该方法的实现，它会在其父类中逐级向上查找，直到找到方法实现为止。

比如下面的代码：

public class Car {
    public void run() {
        System.out.println("Car is running");
    }
}

public class BMW extends Car {
    @Override
    public void run() {
        System.out.println("BMW is running");
    }
}

public class Benz extends Car {
    @Override
    public void run() {
        System.out.println("Benz is running");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new BMW();
        Car car2 = new Benz();

        car1.run(); // output: BMW is running
        car2.run(); // output: Benz is running
    }
}

在这个例子中，BMW和Benz都继承了Car类，并重写了它的run()方法。在创建car1和car2对象时，使用了继承和多态的概念。在运行时，JVM会根据对象的实际类型来确定run()方法的实现，这是动态绑定的过程。

总结

静态绑定和动态绑定的区别就是方法调用时绑定的时间不同，静态绑定在编译期间绑定，动态绑定在运行期间绑定。通常情况下，我们都使用动态绑定，因为它能够提高代码的扩展性和可维护性。