文章介绍了Java中的动态绑定机制，即在通过对象调用方法时，方法会与对象的实际类型绑定，而非声明类型的绑定。通过一个父子类的示例，展示了在多态调用中，即使父类引用调用的方法在子类中被重写，实际执行的将是子类的方法。同时，文章强调了属性访问并不遵循动态绑定，而是按照继承层次查找。在提供的课堂练习中，解释了如何利用动态绑定机制进行方法调用，并给出了调用结果的分析。
目录
一、前言 :
在java 面向对象三大特性——继承篇中，我们说过java 中查找方法的顺序为 : 本类方法—>父类方法—>更高一级的父类—>......Object(顶层父类) 。然而，在某些情况下，这样的原则也会被凌驾。今天我们要说的java动态绑定机制，就是这样一个区别于继承机制的例外。
二、特点 :
-
当通过对象的形式调用方法时，该方法会和堆内存中真正的该对象——的内存地址绑定，且这种绑定关系会贯穿方法的执行全过程。这就是所谓的“动态绑定机制”。
-
当通过对象的形式调用属性时，不存在动态绑定机制，符合继承机制——即java中查找变量的顺序 : 局部变量—>成员变量—>父类—>更高的父类—>......—>Object 。
三、演示 :
1.准备工作 :
up以Father类为父类，Son类为子类（仅用作演示，无实际意义）。以TestBinding为测试类。还是老规矩，为了代码简洁，up这次将Father类和Son类写在了TestBinding类的源文件中。（PS : 其实不应该把测试类和子父类放一块儿的，但是动绑机制需要更直观地对比才好理解，就先这么干了）。
注意，我们要怎么测试动态绑定机制呢？别急，先来看看代码情况 :
up首先在Father类和Son类定义同名的成员变量temp，并且在子父类中各自给出temp变量的获取方法——即temp的getter方法——getTemp();。然后，分别在父类和子类定义两个关于temp变量的计算方法add_temp() 和 add_temp_EX() ，相当于Son类重写了父类这两个方法。其中 : 父类的add_temp() 方法和子类的add_temp_EX()方法中要调用getTemp()方法。最后，在测试类中利用多态的方式调用这两个方法。
TestBinding类，Father类，以及Son类代码如下 :
package knowledge.polymorphism.auto_bind;
public class TestBinding { /** 测试类 */
public static void main(String[] args) {
//建立多态关系
Father father = new Son();
System.out.println(father.add_temp());
System.out.println(father.add_temp_EX());
}
}
class Father { /** 父类 */
//父类的成员变量
int temp = 5;
//父类temp变量的getter方法
public int getTemp() {
return temp;
}
//父类的两个关于计算temp变量的成员方法
//方法一
public int add_temp() {
return getTemp() + 10;
}
//方法二
public int add_temp_EX() {
return temp + 10;
}
}
class Son extends Father { /** 子类 */
//子类的成员变量（与父类成员变量同名）
int temp = 11;
//子类temp变量的getter方法
public int getTemp() {
return temp;
}
//子类的两个关于计算temp变量的成员方法
//方法一
public int add_temp() {
return temp + 100;
}
//方法二
public int add_temp_EX() {
return getTemp() + 1000;
}
}
2.开始测试 :
① 在测试类中，有两条输出语句，是通过父类引用调用成员方法。我们知道，根据多态中成员方法的使用规则——编译看左，运行看右：父类引用，说明编译类型是父类类型，而父类中定义了这两个方法，因此编译没问题，可调用；又因为多态关系——父类引用此时指向了子类对象，因此运行类型为子类，子类重写了父类的这两个方法，当然要优先调用子类中的方法。
所以我们来看，当前情况下，子类add_temp() 方法返回的是temp + 100，根据java中属性的查找原则，现在该方法内并没有定义temp局部变量，且子类定义了自己的temp成员变量，因此返回的“temp + 10”中，temp = 11。所以调用第一个方法最后的返回结果是111。
调用第二个方法 : 同理，子类add_temp()_EX 方法返回的是getTemp() + 1000，本类getTemp() 方法又返回了本类的temp变量。所以调用第二个方法最后的返回结果是1011。
运行结果如下 :
② 看完演示①之后，可能就要有p小将（Personable小将，指风度翩翩的人）出来(挑刺儿)说理了 : 这tm（题目）演示的不就是继承篇讲得那一回事儿吗，看不出哪儿来的动态绑定机制😅？
p小将你先别急，讲东西总是要铺垫的嘛。这不就来了？现在，我们在演示①的基础上，注释掉子类的add_temp() 方法，如下图所示 :
大家注意，根据多态中成员方法的使用规则，本来我是优先调用子类的add_temp() 方法，但是现在它被注释掉了，没法儿用！因此，根据继承机制，现在要去调用父类的add_temp() 方法。up先把父类和子类的代码截图放下面，方便大家思考，就不用往上翻了，如下图 :
没错，现在我们要去调用父类的add_temp() 方法了，但是问题来了 : 父类的add_temp() 方法中调用了getTemp() 方法，那这时候的getTemp() 方法是用谁的呢？
这里就是一个初学者大概率犯错误的地方，如果没有了解过动态绑定机制，它们会想当然的认为 : 现在执行的是Father类中的add_temp() 方法，根据java中查找方法的原则，当然是使用Father类本类的getTemp() 方法了！所以，最后的返回值就是5 + 10 = 15，输出15。但是真的是如此吗 ?
运行结果如下 :
输出结果表明父类add_temp() 方法最后返回的不是5 + 10，而是11 + 10，这表明add_temp() 方法中调用的getTemp() 方法是子类中的getTemp() 方法。为什么呢？
原因就是我们说的动态绑定机制，由于测试类中是通过father引用来调用方法，而它指向的堆空间中真正的对象其实是Son类对象。根据动态绑定机制，在调用add_temp() 方法时，father引用已经和它指向的Son类对象绑定了，并且这种绑定关系会贯穿方法执行的全过程。因此，这里调用的getTemp() 方法是子类的方法，而不是父类的。
③ 我们在演示②的基础下，把子类的add_temp_EX() 方法也给注释掉，如下图所示 :
与演示②同理，由于子类重写的add_temp_EX() 方法被注释掉，因此要使用父类的add_temp_EX() 方法。up还是将Father类代码和Son类代码的截图给大家放下面，就不用再往上翻了，如下图所示 :
那么问题又来了 : 此时调用add_temp_EX() 方法，返回的究竟是5 + 10呢，还是11 + 10呢？
相信大家现在就没啥疑问了，前面我们说了 : 调用属性时，不存在动态绑定机制，符合继承机制。因此，根据Java中查找属性的原则，这里的temp变量肯定是Father类本类的temp成员变量，也就是5。所以，最后输出的结果自然是5 + 10 = 15。
运行结果如下 :
四、练习 :
课堂练习 : (找朋友问题）
1.现在有父类People类，以及它的子类Friends类，测试类为Find_friend类。
与我们上文“演示”中的代码类似：People类和Friends类中各自定义了同名变量name，并赋予不同的初值；子父类中分别给出name变量的获取方法——即name的getter方法——getName();。然后，分别在父类和子类给出两个不同的用于拼接字符串的方法find_friends() 和 find_friends_EX()，最后在测试类中建立People—friends类的多态关系，在输出语句中利用People类引用分别调用这两个方法，问 : 最后的输出结果分别是什么 ?
Find_friend类，People类，以及Friends类代码如下 :
package knowledge.polymorphism.auto_bind;
public class Find_friend { /** 测试类：找朋友类 */
public static void main(String[] args) {
//多态
People people = new Friends();
System.out.println("普通版找朋友，找到了谁————" + people.make_friends());
System.out.println("牛逼版找朋友，找到了谁————" + people.make_friends_EX());
}
}
class People { /** 父类：People类 */
//父类的name变量
String name = "刻晴";
//父类name的getter方法
public String getName() {
return name;
}
//父类的两个拼接字符串方法
//方法一
public String make_friends() {
return getName() + " and " + "琪亚娜";
}
//方法二
public String make_friends_EX() {
return make_friends() + " and " + "周杰伦";
}
}
class Friends extends People { /** 子类：Friends类 */
//子类同名变量
String name = "吴京";
//子类name的getter方法
public String getName() {
return name;
}
//子类的两个拼接字符串方法（相当于重写了父类的这两个方法）
//方法一
public String make_friends() {
return super.getName();
}
//方法二
public String make_friends_EX() {
return super.make_friends_EX() + " and " + name;
}
}老规矩，up还是把子父类的代码截图给大家放下面，便于大家思考，如下图所示 :
答案 : (输出结果如下 : )
讲解 :
由于People类引用指向了Friends类对象，因此构成了People类—Friends类之间的多态关系。根据多态关系中成员方法的使用规则，编译类型是People类，而People类中定义了这两个找朋友方法，因此编译没问题，方法可调用；又因为子类重写了父类的两个找朋友方法，且没有被注释，因此优先使用Friends中的找朋友方法。
来看第一个方法的调用：首先找到子类的make_friends() 方法，返回的是super关键字指定的getName() 方法，即父类的getName() 方法；父类的getName() 方法中直接返回了name属性，而我们上面就讲了，调用属性时，不存在动态绑定机制，符合继承机制，父类定义了自己的name属性，因此getName() 方法最后返回的是"刻晴"，所以make_friends() 方法最后返回的是"刻晴"。
来看第二个方法的调用：首先找到子类的make_friends_EX()方法，返回的是父类的make_friends_EX() 方法返回的内容——加上一个字符串" and "——加上一个name变量。好滴，我们一个一个来看，父类的make_friends_EX() 方法的返回值与子类的make_friends_EX() 方法类似，也是一个字符串拼接的形式。但是注意，动态绑定机制来了。由于是通过对象的形式来调用的该方法，所以people引用会和堆内存中真正的Friends类对象的地址值绑定，并贯穿方法执行的全过程。
因此，父类的make_friends_EX() 方法中返回的第一个值——即make_friends() 方法的返回值——应该是调用子类的make_friends() 方法后的返回值，而子类的make_friends() 方法不就是我们刚才解释的第一个方法的调用么，返回的值是"刻晴"。因此，父类的make_friends_EX() 方法最后返回的值就是"刻晴 and 周杰伦"。我们再回到一开始的子类的make_friends_EX() 方法，name的值即本类的name属性的值"吴京"。所以make_friends_EX() 方法最后返回的是"刻晴 and 周杰伦 and 吴京"。
五、结束：
🆗，我们的动绑机制就说到这里，大家一定要牢记动绑机制的两大特点。感谢阅读！
最后再给大家抛出一个问题吧，在上面的练习中，如果注释掉子类的两个找朋友方法，那最后的输出结果分别又是什么呢？大家可以思考一下。
扫一扫
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
