java 继承之上——动绑机制详解

文章介绍了Java中的动态绑定机制,即在通过对象调用方法时,方法会与对象的实际类型绑定,而非声明类型的绑定。通过一个父子类的示例,展示了在多态调用中,即使父类引用调用的方法在子类中被重写,实际执行的将是子类的方法。同时,文章强调了属性访问并不遵循动态绑定,而是按照继承层次查找。在提供的课堂练习中,解释了如何利用动态绑定机制进行方法调用,并给出了调用结果的分析。
摘要由CSDN通过智能技术生成

目录

一、前言 :

二、特点 :

三、演示 :

四、练习 :

五、结束:


一、前言 :

        在java 面向对象三大特性——继承篇中,我们说过java 中查找方法的顺序为 : 本类方法—>父类方法—>更高一级的父类—>......Object(顶层父类) 然而,在某些情况下,这样的原则也会被凌驾。今天我们要说的java动态绑定机制,就是这样一个区别于继承机制的例外。

二、特点 :

  1. 通过对象的形式调用方法时,该方法会和堆内存中真正的该对象——的内存地址绑定,且这种绑定关系贯穿方法的执行全过程。这就是所谓的“动态绑定机制”。

  2. 当通过对象的形式调用属性时,不存在动态绑定机制,符合继承机制——即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 吴京"

五、结束:

        🆗,我们的动绑机制就说到这里,大家一定要牢记动绑机制的两大特点感谢阅读!

        最后再给大家抛出一个问题吧,在上面的练习中,如果注释掉子类的两个找朋友方法,那最后的输出结果分别又是什么呢?大家可以思考一下。

评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cyan_RA9

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值