java - 静态与。 Java中的动态绑定(bind)

Question

我目前正在为我的一个类做作业，在其中，我必须使用Java 语法给出静态 和动态绑定(bind) 的示例。

我了解基本概念，即静态绑定(bind)发生在编译时，动态绑定(bind)发生在运行时，但我无法弄清楚它们具体是如何工作的。

我在网上找到了一个静态绑定(bind)的例子，给出了这个例子:

public static void callEat(Animal animal) {
    System.out.println("Animal is eating");
}

public static void callEat(Dog dog) {
    System.out.println("Dog is eating");
}

public static void main(String args[])
{
    Animal a = new Dog();
    callEat(a);
}

这会打印“动物在吃东西”，因为对 callEat 的调用使用静态绑定(bind)，但我不确定为什么 这被认为是静态绑定(bind)。

到目前为止，我所看到的任何资料都无法以我可以理解的方式解释这一点。

Answer 1

来自 Javarevisited blog post :

Here are a few important differences between static and dynamic binding:

1. Static binding in Java occurs during compile time while dynamic binding occurs during runtime.
2. private, final and static methods and variables use static binding and are bonded by compiler while virtual methods are bonded during runtime based upon runtime object.
3. Static binding uses Type (class in Java) information for binding while dynamic binding uses object to resolve binding.
4. Overloaded methods are bonded using static binding while overridden methods are bonded using dynamic binding at runtime.

Here is an example which will help you to understand both static and dynamic binding in Java.

Static Binding Example in Java

public class StaticBindingTest {  
    public static void main(String args[]) {
        Collection c = new HashSet();
        StaticBindingTest et = new StaticBindingTest();
        et.sort(c);
    }
    //overloaded method takes Collection argument
    public Collection sort(Collection c) {
        System.out.println("Inside Collection sort method");
        return c;
    }
    //another overloaded method which takes HashSet argument which is sub class
    public Collection sort(HashSet hs) {
        System.out.println("Inside HashSet sort method");
        return hs;
    }
}

Output: Inside Collection sort method

Example of Dynamic Binding in Java

public class DynamicBindingTest {   
    public static void main(String args[]) {
        Vehicle vehicle = new Car(); //here Type is vehicle but object will be Car
        vehicle.start(); //Car's start called because start() is overridden method
    }
}

class Vehicle {
    public void start() {
        System.out.println("Inside start method of Vehicle");
    }
}

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Inside start method of Car");
    }
}

Output: Inside start method of Car