hi,你好!欢迎访问本站!登录
本站由网站地图腾讯云宝塔系统阿里云强势驱动
当前位置:首页 - 教程 - 杂谈 - 正文 君子好学,自强不息!

【深切明白多态】从“妈妈我想吃烤山药”讲起

2019-11-18杂谈搜奇网33°c
A+ A-

目次

  • 1、从吃烤山药从新认识多态
  • 2、 多态条件条件【重点】
  • 3、 多态的表现
  • 4、向上转型
  • 5、向下转型
  • 6、向上向下转型再次剖析【加餐不加价】
  • 7、多态与组织器之间的玄妙
  • 8、多态的长处
  • 9、剖析开篇的九个题目
  • 10、末了我们一同来正式剖析那九个题

@

在我认为多态相对是面向对象的第三大特征中让许多小白同砚以及初学者难以逾越的鸿沟,因为多态有许多细节性的学问,不花点时刻,还真不好邃晓多态。这么说吧,假如你认为你已完整邃晓了多态,你无妨做做下面的顺序,假如你能全都答对,那没题目了,多态对你来讲真的不是题目!假如在第四个就趴下了,那能够看看这篇文章,也许对你有所协助,能够会让你从新见地到多态的魅力。

package Polymorphic;
//爷爷类
class Ye {
    public String show(Sun obj) {
        return ("Ye and Sun");
    }

    public String show(Ye obj) {
        return ("Ye and Ye");
    }

}
//爸爸类
class Fu extends Ye {
    public String show(Fu obj) {
        return ("Fu and Fu");
    }

    public String show(Ye obj) {
        return ("Fu and Ye");
    }
}
//儿子类
class Zi extends Fu {

}
//孙子类
class Sun extends Fu {

}

public class PolymorphicTest {
    public static void main(String[] args) {
         Ye y = new Ye();
        Ye y2 = new Fu(); //向上
        Fu f = new Fu();
        Zi z = new Zi();
        Sun s = new Sun();


        System.out.println("第一题 " + y.show(f));
        System.out.println("第二题 " + y.show(z));
        System.out.println("第三题 " + y.show(s));
        System.out.println("第四题 " + y2.show(f));  //到这里挂了???
        System.out.println("第五题 " + y2.show(z));
        System.out.println("第六题 " + y2.show(s));
        System.out.println("第七题 " + f.show(f));
        System.out.println("第八题 " + f.show(z));
        System.out.println("第九题 " + f.show(s));
     
    }
}

先把答案记在小本本上吧,再对比下面结果看看

第一题 Ye and Ye
第二题 Ye and Ye
第三题 Ye and Sun
第四题 Fu and Ye
第五题 Fu and Ye
第六题 Ye and Sun
第七题 Fu and Fu
第八题 Fu and Fu
第九题 Ye and Sun

假如你对上面的结果很不测,或许不解,那末祝贺你,你又能学到新学问了,胜利的向架构师前进了一步!好了,让我们一同从新见地见地多态的魅力吧!

1、从吃烤山药从新认识多态

近来不是正火着吃烤山药么,进修就要走风趣化线路,毕竟兴致永久最好的先生,咋们放开点,怎样风趣怎样来。

小明妈妈的心境非常不稳定,心境好的时刻恨不得给小明花一个亿,,心境不好的时刻恨不得把小明打成麻瓜,然则小明永久不晓得妈妈的心境变化。这不,本日一名老大爷在卖烤山药,边烤还边跳激光雨,嗨得不可,小明迥殊喜好激光雨,立时就不由得了,内心默默想着,刚烤的山药它不香嘛,激光雨烤的山药它不香嘛。因而不由得对妈妈说:“妈妈,我想吃烤山药”,这个时刻,来了,来了,他来了,它真的来了....你冲动个锤子啊......是代码来了:

package Polymorphic;


     class  Matcher{
        public void matcherSpeak(){
            System.out.println("想吃烤山药?");
        }
    }

     class HappyMother extends Matcher {
        public void matcherSpeak(){
            System.out.println("高兴的妈妈说:吃,吃大块的,一火车够吗");
        }
    }

     class SadMother extends Matcher {
        public void matcherSpeak(){
            System.out.println("不高兴的妈妈说:吃你个憨皮,看我回家扎不扎你就完事了");
        }
    }

     class VeryHappyMother extends Matcher {
        public void matcherSpeak(){
            System.out.println("非常高兴的妈妈说:买买买,烤山药咱全买了,顺便把大爷也买回家,天天给你扮演激光雨(大爷懵逼中)");
        }
    }

    public class UnderstandPolymorphic{
        public static void main(String[] args) {
            Matcher m = new HappyMother();
            m.matcherSpeak();

            m = new SadMother();
            m.matcherSpeak();

            m = new VeryHappyMother();
            m.matcherSpeak();

        }
    }
运转结果:

高兴的妈妈说:吃,吃大块的,一火车够吗
不高兴的妈妈说:吃你个憨皮,看我回家扎不扎你就完事了
非常高兴的妈妈说:买买买,烤山药咱全买了,顺便把大爷也买回家,天天给你扮演激光雨(大爷懵逼中)

妈妈听到小明想吃烤山药这统一行动,表现出差别的表现形式,这就是多态。多态专业定义则是:顺序中定义的援用变量所指向的细致范例和经由历程该援用变量发出的要领挪用在编程时并不肯定,而是在顺序运转时期才肯定,这类状况叫做多态没错是没错就是脑袋有点大,所以我挑选简朴点定义多态: 多态指统一行动,具有多个差别表现形式。为什么会有云云玄妙的变化呢,那我们就必需相识举行多态的条件了。

2、 多态条件条件【重点】

假如多态不能满足以下三个条件条件,那还玩犊子的多态【构不成多态,缺一不可】

  1. 继续或许完成【二选一】
  2. 要领的重写【意义表现:不重写,无意义】
    子类对父类中某些要领举行从新定义,在挪用这些要领时就会挪用子类的要领。
  3. 父类援用指向子类对象(也能够说向上转型)【表如今花样上】

回过头来看烤山药例子,确切都有继续,一样都重写了motherSpeak()要领,最症结的代码则是

 Matcher m = new HappyMother();

也就是所谓的 父类援用指向子类对象,这实在就是向上转型!对向上转型观点不清晰没事,下面会细致解说。

3、 多态的表现

多态表现的花样: 父类/父接口范例 变量名 = new 子类对象变量名.要领名();

当运用多态体式格局挪用要领时,起首搜检父类中是不是有该要领,假如没有,则编译毛病 ,假如有,实行的是子类重写后的要领,也就是向上转型时, 子类零丁定义的要领丧失题目。编译报错。 代码以下:

package Demo;

class  Matcher{
    public void matcherSpeak(){//=========================父类matcherSpeak()要领
        System.out.println("吃烤山药?");
    }
}

class HappyMother extends Matcher {
    public void matcherSpeak(){//=========================子类matcherSpeak()要领
        System.out.println("高兴的妈妈说:吃,吃大块的,一蛇皮袋够吗");
    }

    public void fatherSpeak(){//=========================子类独占的fatherSpeak()要领
        System.out.println("高兴的妈妈说:吃,吃大块的,一麻袋够吗");
    }
}
public class Test {
    public static void main(String[] args) {
        Matcher m=new HappyMother();
        m.matcherSpeak();
        m.fatherSpeak();  //编译失利,没法剖析fatherSpeak要领
    }
}

剖析以下:

固然这个例子只是入门级的,接下来看个有点程度的例子

package Demo;

class  Matcher{
    public void matcherSpeak(){
        System.out.println("想吃烤山药?");
    }

}

class HappyMother extends Matcher {
    public void matcherSpeak(){
        System.out.println("高兴的妈妈说:吃,吃大块的,一火车够吗");
    }
}
class SadMother extends HappyMother{
    public void tt(){
        System.out.println("ttttttt");
    }
}
public class Test {
    public static void main(String[] args) {
        Matcher mm=new SadMother();
        mm.matcherSpeak();
    }

运转结果:高兴的妈妈说:吃,吃大块的,一火车够吗
}

有了第一个基础这个置信不难邃晓,接着看

package Demo;

class  Matcher{
    public void matcherSpeak(){
        System.out.println("想吃烤山药?");
    }
}

class HappyMother extends Matcher {
    
}
class SadMother extends HappyMother{
    public void tt(){
        System.out.println("ttttttt");
    }
}
public class Test {
    public static void main(String[] args) {
        Matcher mm=new SadMother();
        mm.matcherSpeak();
    }
    
运转结果:想吃烤山药?

}

到这里,再来回味下这句话:

当运用多态体式格局挪用要领时,起首搜检父类中是不是有该要领,假如没有,则编译毛病 ,假如有,实行的是子类重写后的要领

你能够会说子类中都没有这些个要领啊,何来实行子类重写后的要领一说?它好像是去父类中找该要领了。事实上,子类中是有这些要领的,这个要领继续自父类,只不过没有掩盖该要领,所以没有在子类中邃晓写出来罢了,看起来像是挪用了父类中的要领,现实上挪用的照模样类中的。同砚继续方面的学问该补补了,能够参考下面这篇【java基础】java继续从“我爸是李刚”讲起

4、向上转型

向上转型:多态自身是子类范例向父类范例向上转换的历程,个中,这个历程是默许的。你能够把这个历程邃晓为基础范例的小范例转大范例自动转换,不须要强迫转换。 当父类援用指向一个子类对象时,就是向上转型。 向上转型花样:

父类范例 变量名 = new 子类范例(); 如:Father f= new Son();

例子的话,烤山药的例子就是一个典范的向上转型例子

5、向下转型

向下转型:父类范例向子类范例向下转换的历程,这个历程是强迫的。一样能够把这个历程邃晓为基础范例的自动转换,大范例转小范例须要强迫转换。一个已向上转型的子类对象,将父类援用转为子类援用,能够运用强迫范例转换的花样,向下转运用花样:

Father father = new Son();
子类范例 变量名 = (子类范例) 父类变量名; 如:Son s =(Son) father;

不晓得你们有无发明,向下转型的条件是父类对象指向的是子类对象(也就是说,在向下转型之前,它得先向上转型),固然,向下转型照样有它的意义地点,下面就解说向下转型的意义。

到这里,我们解说一下为什么要向下转型?上面已讲到过当运用多态体式格局挪用要领时,起首搜检父类中是不是有该要领,假如没有,则编译毛病。也就是说,不能挪用子类具有,而父类没有的要领。编译都毛病,更别说运转了。这也是多态给我们带来的一点"小麻烦"。所以,想要挪用子类特有的要领,必需做向下转型

package Demo;

class  Matcher{
    public void eat(){
        System.out.println("想吃烤山药?");
    }
}

class XiongHaiZi extends Matcher {
    public void eat(){
        System.out.println("妈妈,我想吃烤山药");
    }

    public void eatSuLi(){//============================子类特有的eatSuLi要领
        System.out.println("麻麻,我想吃酥梨,要吃麻瓜那末大的酥梨");
    }
}

public class Test {
    public static void main(String[] args) {
        
        Matcher m = new XiongHaiZi();//向上转型
        
        XiongHaiZi x = (XiongHaiZi)m;//向下转型
        
        x.eatSuLi();//实行子类特有要领

    }
    
    运转结果:麻麻,我想吃酥梨,要吃麻瓜那末大的酥梨
}

好了向下转型就讲到这里...等等,你真的认为就讲完了?肯定不可喽,向下转型另有一个要说的学问,讲之前先来看个顺序先

package Demo;

class  Matcher{
    public void eat(){
        System.out.println("想吃烤山猪?");
    }

}

class Boy extends Matcher {
    public void eatKaoYang(){
        System.out.println("妈妈,我想吃烤山猪");
    }
}

class Girl extends Matcher {
    public void eatKaoYang(){
        System.out.println("妈妈,我想吃烤山猪2333");
    }
}

public class Test {
    public static void main(String[] args) {

        Matcher g = new Girl();//向上转型编译经由历程

        Boy x = (Boy)g;//向下转型

        x.eatKaoYang();//编译经由历程,但运转报ClassCastException

    }
    
 运转结果:  运转报ClassCastException

}

这段代码能够经由历程编译,然则运转时,却报出了 ClassCastException ,范例转换非常!这是因为,明显建立了Girl范例对象,运转时,固然不能转换成Boy对象的。这两个范例并没有任何继续关联,不符合范例转换的定义。 为了防备ClassCastException的发作,Java供应了 instanceof 症结字,给援用变量做范例的校验。

instanceof的运用

instanceof 的花样:
变量名 instanceof 数据范例

instanceof 的运用
假如变量属于该数据范例,返回true。
假如变量不属于该数据范例,返回false。

所以,转换前,我们最好运用instanceof 先做一个推断,代码以下:

package Demo;

class  Matcher{
    public void eat(){
        System.out.println("想吃烤山药?");
    }

}

class Boy extends Matcher {
    public void eatKaoYang(){
        System.out.println("Boy:妈妈,我想吃烤羊");
    }
}

class Girl extends Matcher {
    public void eatKaoYang(){
        System.out.println("Girl:妈妈,我想吃烤全羊2333");
    }
}

public class Test {
    public static void main(String[] args) {

        Matcher g = new Girl();//向上转型

        if(g instanceof Girl){
            Girl x = (Girl)g;//向下转型
            x.eatKaoYang();  //=====================挪用Girl的eatKaoYang()要领
        }else if(g instanceof Boy){ //不实行
            Boy x = (Boy)g;//向下转型
            x.eatKaoYang();  //=====================挪用Boy的eatKaoYang()要领
        }
    }
}

运转结果: Girl:妈妈,我想吃烤全羊2333

好了到这里,你get到了咩?

6、向上向下转型再次剖析【加餐不加价】

看完以后是不是是照样不够清晰向上向下转型?多态转型题目实在并不庞杂,只需记着一句话:父类援用指向子类对象。那什么叫父类援用指向子类对象?看下面例子吧

有两个类,Father 是父类,Son 类继续自 Father

第 1 个例子:

//  f1 援用指向一个Son对象
Father f1 = new Son();   // 这就叫 upcasting (向上转型)
// f1 照样指向 Son对象
Son s1 = (Son)f1;   // 这就叫 downcasting (向下转型)

第 2 个例子:

// f1如今指向father对象
Father f2 = new Father();
Son s2 = (Son)f2;       // 失足,子类援用不能指向父类对象

你也许会问,第1个例子中:Son s1 = (Son)f1; 为什么是准确的呢。很简朴因为 f1 指向一个子类对象,Father f1 = new Son(); 子类 s1 援用固然能够指向子类对象了。

f2 被传给了一个 Father 对象,Father f2 = new Father(); 子类 s2 援用不能指向父类对象。

7、多态与组织器之间的玄妙

直接上代码:

package Polymorphic;

class EatKaoShanYao {
    EatKaoShanYao () {
        System.out.println("吃烤山药之前...");
        eat();
        System.out.println("吃烤山药以后(熊孩子懵逼中)....");
    }
    public void eat() {
        System.out.println("7岁半就喜好吃烤山药");
    }
}
public class KaoShanYao extends EatKaoShanYao {
    private String Weight = "110斤";
    public KaoShanYao(String Weight) {
        this.Weight = Weight;
        System.out.println("熊孩子的体重:" + this.Weight);
    }

    public void eat() { // 子类掩盖父类要领
        System.out.println("熊孩子吃烤山药之前的体重是:" + this.Weight);
    }

    //Main要领
    public static void main(String[] args) {
           EatKaoShanYaok = new KaoShanYao("250斤");
                      
    }
}

童鞋们能够试想一下运转结果,再看下面的输出结果

 运转结果:
                吃烤山药之前...
                熊孩子吃烤山药之前的体重是:null
                吃烤山药以后(熊孩子懵逼中)....
                熊孩子的体重:250斤

是不是是很迷惑?结果为啥是如许?你看,熊孩子又懵逼了,Why?

缘由实在很简朴,因为在建立子类对象时,会先去挪用父类的组织器,而父类组织器中又挪用了被子类掩盖的多态要领,因为父类并不清晰子类对象中的属性值是什么(先初始化父类的时刻还没最先初始化子类),因而把String范例的属性临时初始化为默许值null,然后再挪用子类的组织器(这个时子类组织器已初始Weight属性,所以子类组织器晓得熊孩子的体重Weight是250)。

假如有什么不邃晓的能够实时通知我,楼主一向都在,另有假如楼主那里写错了或许邃晓错了,请实时通知我,肯定要通知我!!!

8、多态的长处

讲了这么久的多态,我认为其长处已不明觉厉了。然则照样来聊聊多态在现实开辟的历程当中的长处。在现实开辟中父类范例作为要领形式参数,通报子类对象给要领,举行要领的挪用,更能表现出多态的扩大 性与方便。
为了更好的对比出多态的长处,下面顺序不运用多态,代码以下:

package Demo;
//父类:动物类
class Animal{
    public void eat(){
        System.out.println("eat");
    }
}
//猫类
class Cat {
    //要领重写
    public void eat(){
        System.out.println("猫吃猫骨头");
    }
    public void call(){
        System.out.println("猫叫");
    }
}
//狗类
class Dog {
    public void eat(){
        System.out.println("狗吃狗骨头");
    }
    public void call(){
        System.out.println("狗叫");
    }
}

//针对动物操纵的东西类
class AnimalTool{

    private AnimalTool(){}//把东西类的组织要领私有,防备他人建立该类的对象。

    //挪用猫的功用
    public static void catLife(Cat c){  //东西类,要领就写成static的,然后直接在测试类:东西类名.要领 运用。
        c.eat();
        c.call();
    }
    //挪用狗的功用
    public static void dogLife(Dog d){
        d.eat();
        d.call();
    }
}

public class Test{
    public static void main(String[] args){

        Cat c= new Cat();
        AnimalTool.catLife(c);

        Dog d= new Dog();
        AnimalTool.dogLife(d);

    }
}
运转结果:
        猫吃猫骨头
        猫叫
        狗吃狗骨头
        狗叫

这里只写了两只动物,假如再来一种动物猪,则须要定义个猪类,供应猪的两个要领,再到东西类中增加对应的XXLife要领,这三步都是必需要做的,而且每多一种动物就须要在东西类中增加一种一个对应的XXLife要领,如许保护起来就很麻烦了,毕竟动物品种不计其数!崩溃吧,没事多态来挽救你,以下运用多态代码:

package Demo;
//父类:动物类
class Animal{
    public void eat(){
        System.out.println("eat");
    }
    public void call(){
        System.out.println("call");
    }
}
//猫类
class Cat extends Animal {
    //要领重写
    public void eat(){
        System.out.println("猫吃猫骨头");
    }
    public void call(){
        System.out.println("猫叫");
    }
}
//狗类
class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃狗骨头");
    }
    public void call(){
        System.out.println("狗叫");
    }
}

//针对动物操纵的东西类
class AnimalTool{

    private AnimalTool(){}//最好把东西类的组织要领私有,防备他人建立该类的对象。该类是东西类。

    //挪用所以动物的功用
    public static void animalLife(Animal a){  //东西类,要领就写成static的,然后直接在测试类:东西类名.要领 运用。
        a.eat();
        a.call();
    }

}

public class Test{
    public static void main(String[] args){

        Cat c= new Cat();
        AnimalTool.animalLife(c);

        Dog d= new Dog();
        AnimalTool.animalLife(d);
运转结果:
        猫吃猫骨头
        猫叫
        狗吃狗骨头
        狗叫
    }
}

注重: 上面动物类都继续了animal父类

这个时刻再剖析,假如再来一种动物猪,则须要定义个猪类,供应猪的两个要领,再继续Animal父类,这个时刻就不须要在东西类中增加对应的XxLife要领,只写一个animalLife要领即可,而且每多一种动物都不须要在东西类中增加对应的XxLife要领,如许保护起来就很乐观了。

因为多态特征的支撑,animalLife要领的Animal范例,是CatDog的父类范例,父类范例吸收子类对象,当 然能够把Cat对象和Dog对象通报给要领。 当eatcall要领实行时,多态划定,实行的是子类重写的要领,那末结果天然与Animal的子类中的eatcall要领一致, 所以animalLife完整能够替换以上两要领。 不仅仅是替换,在扩大性方面,不管以后再多的子类涌现,我们都不须要编写XxLife要领了,直接运用 animalLife就能够完成。 所以,多态的优点,表如今能够使顺序编写的更简朴,并有优越的扩大。

9、剖析开篇的九个题目

看到这里,置信童鞋们多多少少都应该对多态都肯定的相识了,都应该很有自信心处理开篇的困难了吧,我能够很担任的通知你,文章看到这里,你照旧处理不了这几个题目,不要问我为啥晓得,你能够试着再做一遍,代码贴在下面:

package Polymorphic;
//爷爷类
class Ye {
    public String show(Sun obj) {
        return ("Ye and Sun");
    }

    public String show(Ye obj) {
        return ("Ye and Ye");
    }

}
//爸爸类
class Fu extends Ye {
    public String show(Fu obj) {
        return ("Fu and Fu");
    }

    public String show(Ye obj) {
        return ("Fu and Ye");
    }
}
//儿子类
class Zi extends Fu {

}
//孙子类
class Sun extends Fu {

}

public class PolymorphicTest {
    public static void main(String[] args) {
         Ye y = new Ye();
        Ye y2 = new Fu(); //向上
        Fu f = new Fu();
        Zi z = new Zi();
        Sun s = new Sun();


        System.out.println("第一题 " + y.show(f));
        System.out.println("第二题 " + y.show(z));
        System.out.println("第三题 " + y.show(s));
        System.out.println("第四题 " + y2.show(f));  //到这里挂了???
        System.out.println("第五题 " + y2.show(z));
        System.out.println("第六题 " + y2.show(s));
        System.out.println("第七题 " + f.show(f));
        System.out.println("第八题 " + f.show(z));
        System.out.println("第九题 " + f.show(s));
     
    }

打印结果:
    第一题 Ye and Ye
    第二题 Ye and Ye
    第三题 Ye and Sun
    第四题 Fu and Ye
    第五题 Fu and Ye
    第六题 Ye and Sun
    第七题 Fu and Fu
    第八题 Fu and Fu
    第九题 Ye and Sun
}

要想邃晓上面这个例子,童鞋们必需读懂这句话:当父类对象援用变量援用子类对象时,被援用对象的范例决议了挪用谁的成员要领,援用变量范例决议可挪用的要领。起首会先去可挪用的要领的父类中寻觅,找到了就实行子类中掩盖的该要领,就算子类中有现成的该要领,它一样也会去父类中寻觅,早到后未必实行子类中有现成的要领,而是实行重写在父类中找到的要领的子类要领(这里的子类也就是末了决议挪用的类要领)。你是不是是晕了?读着都认为拗口,要邃晓可就拗的不是口了而是拗头 ~啥玩意没听过这个词~ 咳咳,题目不大,楼主来浅显的给人人解说,让人人邃晓。

还记不记得楼主之前定义向上转型是怎样定义的?

【v8提醒】 向上转型:多态自身是子类范例向父类范例向上转换的历程,个中,这个历程是默许的。你能够把这个历程邃晓为基础范例的小范例转大范例自动转换,不须要强迫转换。 当父类援用指向一个子类对象时,就是向上转型

然则,你真的邃晓了咩?什么叫做父类对象援用变量援用子类对象?实在还得从下面这句话找眉目

向上转型定义:多态自身是子类范例向父类范例向上转换的历程,个中,这个历程是默许的

就比如Father f = new Son();有的童鞋就会说这个f也算是父类的对象援用?假如按字面邃晓是子类的援用只不过该援用的范例为Father范例?这时候你就大错特错了。

我们把向上转型定义简化一下邃晓一下,简化以下:

子类范例默许向父类范例向上转换的历程

如今邃晓了咩?这句话能够邃晓为Father f = new Son()这句代码原本是Father f = (Father )new Son()如许子的只是这个转换历程是默许自动转的,总的来讲也就是 new Son()实在实质就是new Father,所以f实在就是父类对象援用!这个时刻再来拆开邃晓下面这段话

当父类对象援用变量援用子类对象时

个中父类对象援用变量指的就是f子类对象指的就是new Son(),所以加起来就是当f援用new Son()

被援用对象的范例决议了挪用谁的成员要领,援用变量范例决议可挪用的要领。

这里的 被援用对象的范例则是指new Son()对象中的Son范例, 援用变量范例则是指f的范例Father范例

好了总结关联起来就是当:f援用new Son()时,Son决议了挪用它的成员要领,Father决议可挪用Father中的要领。所以以Father f = new Son()举例,简朴来讲就是

10、末了我们一同来正式剖析那九个题

前三个并没有触及到多态(向上转型),所以只会挪用yeye本类的要领,这里只需控制继续的学问就OK了。

解说第四题之前,你的答案是不是是"Fu and Fu"?来了喔,立时让你巅覆对多态的人生观!

剖析第四题,起首Ye y2 = new Fu(); 向上转型了,所以起首会去Fu类的父类Ye类中找show(f)要领,找到了show(Ye obj)要领,以后回到Fu类中看是不是有show(Ye obj)重写要领,发明Fu类有show(Ye obj)要领(重写),所以末了实行了"Fu and Ye",你get了咩?

剖析第五题,实在第五题和第四题基础差不多,第四题是y2.show(f);第五题是y2.show(z);只是show的要领参数差别,雷同的是fzYe类中找的都是show(Ye obj)要领,所以,终究第四题和第五题结果一致!

剖析第六题,第六题实在挺风趣,起首y2.show(s),到Ye类中找到show(Sun obj),以后在子类中看有无重写,发明并没有show(Sun obj)重写要领,肯定没有咩?别忘了这是继续,子类Fu中默许有着父类Ye的要领,只是没有外表表示出来,从另一角度动身,Fu类中默许重写了一个show(Sun obj)要领,就算不写也是存在的,所以运转结果为"Ye and Sun"

第七、八题就不剖析了,毕竟也没有触及到向上转型(多态)。

末了剖析一下第九题,有的童鞋就要打楼主了,第九题不也是没有触及到向上转型(多态)吗,楼主你个星星(**),固然,楼主就算背着黑锅也要剖析第九题~就是这么傲娇~,确切没有触及到向上转型(多态),我要讲的缘由很简朴,因为我认为照样很有必要!起首f.show(s)不触及多态,它只会挪用本身类(Fu)的要领,然则你会发明Fu中并没有show(s),唉唉唉,我运转你从新组织下言语,又忘了?这是继续啊,它有默许父类Ye中的show(Sun obj)要领鸭!好了到这里,我总结出一点,你多态以及没得题目了,不过你继续方面学问柔弱啊,不可不可楼主得给你补补,还在犹疑什么鸭,快来补补继续学问!!!【java基础】java继续从“我爸是李刚”讲起

本文的末了,我只是个人对多态的邃晓,楼主只是个java小白,叫我老白也行,不肯定悉数准确,假如有什么毛病请肯定要通知我,感激涕零感激涕零感激涕零!!!迎接斧正~

末了的末了,假如本文对你有所协助就点个爱心支撑一下吧 ~佛系报大腿~

迎接列位关注我的民众号,一同讨论手艺,憧憬手艺,寻求手艺...

  选择打赏方式
微信赞助

打赏

QQ钱包

打赏

支付宝赞助

打赏

  移步手机端
【深切明白多态】从“妈妈我想吃烤山药”讲起

1、打开你手机的二维码扫描APP
2、扫描左则的二维码
3、点击扫描获得的网址
4、可以在手机端阅读此文章
未定义标签

本文来源:搜奇网

本文地址:https://www.sou7.cn/282217.html

关注我们:微信搜索“搜奇网”添加我为好友

版权声明: 本文仅代表作者个人观点,与本站无关。其原创性以及文中陈述文字和内容未经本站证实,对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。请记住本站网址https://www.sou7.cn/搜奇网。

发表评论

选填

必填

必填

选填

请拖动滑块解锁
>>