Java 中的静态绑定与动态绑定

java dynamic-binding static-binding

2022-08-31 09:18:04

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

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

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

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);
}

这将打印“动物正在吃”，因为调用调用Eat使用静态绑定，但我不确定为什么这被认为是静态绑定。

到目前为止，我所见过的任何消息来源都没有设法以我可以遵循的方式解释这一点。

答案 1

来自 Javarevisited 博客文章：

以下是静态绑定和动态绑定之间的一些重要区别：

Java 中的静态绑定发生在编译时，而动态绑定发生在运行时。

private，方法和变量使用静态绑定并由编译器绑定，而虚拟方法在运行时基于运行时对象绑定。finalstatic

静态绑定使用（在 Java 中）信息进行绑定，而动态绑定使用对象来解析绑定。Typeclass

重载方法使用静态绑定进行绑定，而重写的方法在运行时使用动态绑定进行绑定。

下面是一个示例，它将帮助您了解 Java 中的静态绑定和动态绑定。

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;
    }
}
输出：内部集合排序方法

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");
    }
}
输出：汽车内部启动方法

答案 2

将方法调用连接到方法主体称为绑定。正如Maulik所说：“静态绑定使用Type（Java中的类）信息进行绑定，而动态绑定使用Object来解析绑定。所以这个代码：

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

class Dog extends Animal {

    public static void main(String args[]) {
        Animal a = new Dog();
        a.eat(); // prints >> dog is eating...
    }

    @Override
    void eat() {
        System.out.println("dog is eating...");
    }
}

将产生结果：狗正在进食......因为它正在使用对象引用来查找要使用的方法。如果我们将上面的代码更改为：

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

class Dog extends Animal {

    public static void main(String args[]) {

        Animal a = new Dog();
        a.eat(); // prints >> animal is eating...

    }

    static void eat() {
        System.out.println("dog is eating...");
    }
}

它将产生：动物正在进食......因为它是一个静态方法，所以它使用Type（在本例中为Animal）来解决要调用的静态方法。除了静态方法之外，私有方法和最终方法使用相同的方法。