介绍
先来看看ai的解释
动态绑定机制是面向对象编程中的一个核心概念，特别是在Java这样的语言中。它允许在运行时根据对象的实际类型来决定调用哪个方法，而不是在编译时。这是多态性的关键特性之一。
在Java中，动态绑定是通过方法调用和方法执行的两个阶段来实现的：
1. **方法调用**：当调用一个对象的方法时，JVM（Java虚拟机）会查看对象的实际类型来决定哪个方法实现应该被调用。如果这个方法在对象的类中被重写，JVM会调用这个重写的方法。这个过程发生在运行时，因为它需要考虑对象的具体类型。
2. **方法执行**：一旦JVM确定了要调用的方法，它就会执行这个方法。在这个过程中，JVM会使用对象的实际类型来查找和执行正确的方法。
动态绑定的关键在于，它允许子类提供特定于自己类型的行为，即使是通过父类的引用来调用方法。这意味着，如果你有一个父类引用指向一个子类对象，当通过这个引用调用一个方法时，实际执行的是子类中定义的那个版本的方法（如果子类重写了这个方法的话）。
为了使动态绑定工作，Java使用了 invokevirtual 指令，这是Java字节码指令集的一部分。当JVM执行 invokevirtual 指令时，它会动态地确定应该调用哪个方法。
这里有一个简单的例子来说明动态绑定：
```java
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog(); // 创建一个Dog对象的引用，但是引用类型是Animal
animal.sound(); // 这将调用Dog类中的sound方法，输出 "Dog barks"
}
}
```
在这个例子中，尽管 `animal` 的引用类型是 `Animal`，但是实际的对象是 `Dog` 类型。因此，当调用 `animal.sound()` 方法时，会动态绑定到 `Dog` 类的 `sound` 方法，输出 "Dog barks"。这就是动态绑定的魔力所在。
个人理解，这里还是离不开我们的编译类型和运行类型。动态绑定是绑定我们的运行类型，并且只对方法进行执行。对于属性则是在哪个类声明就用属性
实操代码
父类和子类
package hansunping;
//创建父类
public class person {
//简单的创建两个属性
private String name;
private int age;
//创建行为方法，方法中调用创建的say方法
public void haviours(){
say();
}
//创建方法
public void say(){
System.out.println("我是人类！！！");
}
}
//blog.csdn.net/YYniannian/article/details/126222600
//创建子类
class Student extends person {//如果没有指定访问修饰符，默认情况下该类具有包私有（package-priva
//te）访问级别，这意味着它只能在同一个包（package）内被访问。
//创建学生的属性
private int score;
//重写行为
// public void haviours(){
// say();
// }
//重写say方法
public void say(){
System.out.println("我是学生！！！");
}
}
分析，我们可以从这里看到父类有haviours，say方法。子类同样有haviour方法和say方法。并且haviour方法调用了say方法。
主类
我们在主类中
package hansunping;
public class demon1 {
public static void main(String[] args) {
person student = new Student();
//调用学生的say（）方法，由于我们的编译类型是Person类，而运行类型是Student类，而动态绑定机制是绑定运行类型。
//所以，当我们调用say（）方法时，是调用Student类的say（）方法
student.haviours();//返回“我是学生”
//、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
//如果我们将student类的say（）方法注销，他寻找student类的say方法无果后，会再向它的父类调用say方法。返回我是人类,效果等同于
}
}
person student = new Student();
person是编译类型。student是运行类型。我们的动态绑定就是与运行类型有关的。
在不注释子类的haviour方法时运行结果为
我是学生！！！
在注释之后结果 还是我是学生！！！
为什么呢？
因为子类的haviou方法不存在。那么根据我们的多态的继承寻找规则，我们就找到了父类的haviou方法。在父类的haviou方法中也是调用了say方法的。那么这个say方法是父类的吗？不是，这个方法应该是子类的。即运行类型的类方法。这里要弄懂编译类型和运行类型
接下来我们看另外一个
代码
package hansunping;
//创建父类
public class person {
//简单的创建两个属性
private String name;
private int age;
public int i =10;
public int sum() {
return getl()+10;
}
public int sum1() {
return i+10;
}
public int getl() {
return i;
}
}
//blog.csdn.net/YYniannian/article/details/126222600
//创建子类
class Student extends person {//如果没有指定访问修饰符，默认情况下该类具有包私有（package-priva
//te）访问级别，这意味着它只能在同一个包（package）内被访问。
//创建学生的属性
public int i =10;
public int sum() {
return getl()+20;
}
public int sum1() {
return i+10;
}
public int getl() {
return i;
}
}
主类
public class demon1 {
public static void main(String[] args) {
person student = new Student();
//调用学生的say（）方法，由于我们的编译类型是Person类，而运行类型是Student类，而动态绑定机制是绑定运行类型。
//所以，当我们调用say（）方法时，是调用Student类的say（）方法
// student.haviours();//返回“我是学生”
System.out.println(student.sum());
System.out.println(student.sum1());
//、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
//如果我们将student类的say（）方法注销，他寻找student类的say方法无果后，会再向它的父类调用say方法。返回我是人类,效果等同于
}
}
运行结果
30
20
好，现在我们同样注释掉子类的sum方法
结果
20
20
那么20是怎么来的，分析一下。student从子类中找不到sum方法，所以从父类找。父类有
public int sum() {
return getl()+10;
}这个，那么这个get1()+10中的getl是父类的还是子类的方法呢？我将父类的
public int i =20;
i为20.如果是父类的话 那么应该是30了。动态绑定即允许环境还是在子类那里。而编译类型是个引用了，这个时候我们要看内存地址而不是指向的引用
我再在子类中添加；
public int getl() {
return i+1000;
}
结果为
1020
20
我们来验证下属性，我将子类的
public int sum() {
return i+30;
}
改成了i+30，发现结果为50
50
20.说明属性还是不变了
