精华内容
下载资源
问答
  • 多态实现

    2019-11-25 20:52:46
    多态实现 多态:一个方法名根据对象不同对应不同实现 多态实现原理:(一个类对应一个字节码文件) 1)静多态(编译期多态/静态绑定)------>函数重载问题(重载:同一个类;函数名相同;参数列表不同) 调用函数...

    多态实现

    多态:一个方法名根据对象不同对应不同实现
    多态实现原理:(一个类对应一个字节码文件)
    1)静多态(编译期多态/静态绑定)------>函数重载问题(重载:同一个类;函数名相同;参数列表不同)
    调用函数是在编译期确定的。
    2)动多态(运行期多态/动态绑定)------->函数重写问题(重写:父子类;函数名相同;参数列表相同)实现原理:地址覆盖
    发生动态绑定的条件
    1)继承 (满足“是一个”的关系)
    2)重写
    3)向上造型(子类到父类,基类的引用,引用的是派生类的对象)
    继承图示/动多态实现原理图
    在这里插入图片描述

    展开全文
  • 今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客...

    前言:

    今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才有了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客让我们从一个完全不懂得状态一步步了解什么是多态,深入掌握多态的概念。

    什么是多态?

    让我们看看百度是怎么定义多态的,话不多说,上图!

    望文生义,第一眼看到多态,感觉就是多种形态的意思,作为Java三大特性之一,多态究竟是什么呢?

    百度已经解释的很清楚了,实际上就是字面意思,拥有多种形态的意思,多态是允许将父类对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

    读到这里好像明白了点,就是让父类拥有更多的属性呗!那看看代码看看是不是这个意思。

    比如父接口是超级英雄(SuperHero)

    public interface SuperHero {
        int age = 0;
        String sex = "";
        //超级英雄的移动方式
        public void move() ;
        //超级英雄的攻击方式
        public void Hit();
    }

    子类A是美国队长(CaptainAmerica)

    public class CaptainAmerica implements SuperHero{
        int age = 89;
        String sex = "男";
        @Override
        public void move(){
            System.out.println("俺是美队,俺跑的移动");
        }
        @Override
        public void Hit() {
            System.out.println("俺是美队,一锅盖悠死灭霸!");
        }
    }

    子类B是钢铁侠(IronMan)

    public class IronMan implements SuperHero{
        int age = 49;
        String sex = "男";
        @Override
        public void move() {
            System.out.println("没想到吧,我会飞,hiahiahia!~");
        }
        @Override
        public void Hit() {
            System.out.println("我是铁男,兄弟,全是高科技,neng死灭霸!");
        }
    }

    然后在main方法中按照多态的定义生成对象:

        public static void main(String[] args) {
            SuperHero superHero = new CaptainAmerica();
            superHero.move();
            superHero.Hit();
            System.out.println(((CaptainAmerica) superHero).sex);
            System.out.println(((CaptainAmerica) superHero).age);
            System.out.println("--------我是华丽的分割线---------");
            superHero = new IronMan();
            superHero.move();
            superHero.Hit();
            System.out.println(((IronMan) superHero).sex);
            System.out.println(((IronMan) superHero).age);
        }

    打印结果:

    俺是美队,俺跑的移动
    俺是美队,一锅盖悠死灭霸!
    男
    89
    --------我是华丽的分割线---------
    没想到吧,我会飞,hiahiahia!~
    我是铁男,兄弟,全是高科技,neng死灭霸!
    男
    49

    嗯,原来这就是多态,so easy,可是短暂的兴奋过后,我突然意识到了一个问题,如果从技术角度去实现的话,我直接用子类去引用子类的对象完全OK啊,无论是从效率还是结果,都完全一样,那么多态有个P用?

    具体实现如下:

        public static void main(String[] args) {
            CaptainAmerica captainAmerica = new CaptainAmerica();
            captainAmerica.move();
            captainAmerica.Hit();
            System.out.println(captainAmerica.sex);
            System.out.println(captainAmerica.age);
            System.out.println("--------我是华丽的分割线---------");
            IronMan ironMan = new IronMan();
            ironMan.move();
            ironMan.Hit();
            System.out.println(ironMan.sex);
            System.out.println(ironMan.age);
        }

    结果如下:

    俺是美队,俺跑的移动
    俺是美队,一锅盖悠死灭霸!
    男
    89
    --------我是华丽的分割线---------
    没想到吧,我会飞,hiahiahia!~
    我是铁男,兄弟,全是高科技,neng死灭霸!
    男
    49

    结果完全相同,而且从代码量上看,后者反而更少一些,那么多态的存在岂不是太显鸡肋?

    后来经过网上的查找,终于找到了多态的终极奥义:

    多态性:发送消息给某个对象,让该对象自行决定响应何种行为。
    通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

    java 的这种机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

    摘自百度知道-https://zhidao.baidu.com/question/101623530.html

    说白了,假设你站在开发者的角度去思考而不是一个苦b的程序猿角度,我要你设计一个漫威英雄生产器,但是用户有不同的需求,有的喜欢钢铁侠,有的喜欢美队,有的都喜欢。所以你应该设计一个接口,里面包含超级英雄的通性,再写出不同的实现类,用户有不同需要的时候,直接从你这个漫威英雄生产器中去找到自己喜欢的英雄,这样会很省事,如果没有这个漫威英雄生产器,你每个超级英雄所有的属性和方法必须自己再一个一个写,虽然也可以,但是很不方便。有了这个通用的接口,什么样的英雄都可以通过给不同的实例化对象让其去引用对象去实现。不知道大家有没有玩儿过红外线灯,通过替换前面不同的灯头,可以射出不同的图案,道理差不多,不安灯头也可以亮,但是没有图案,想要不同的图案只需安装对应的灯头即可,很方便。但是如果没有灯头,你就需要生产拥有不同图案的红外线灯,虽然也能达到射出不同图案的效果,但是要花更多的钱而且麻烦。漫威英雄生产器就相当于这个红外线灯,通过new不同的漫威英雄,以达到射出不同图案的效果,new IronMan();那么就是射出钢铁侠的图案,new CaptainAmerica();就可以射出美队的图案,但是他们都是在漫威英雄这个灯上面,归根到底还是一个红外线灯,但是你每次需要新的漫威英雄,就赋值给对应的类,例如:IronMan ironman = new IronMan(); CaptainAmerica captainAmerica = new CaptainAmerica(); 就相当于又生产了两个红外线灯,试想如果需要更多的超级英雄呢?每个都需要重新生产红外线灯?那不是很麻烦么?

    如果还有疑惑请加我QQ继续探讨~1169213632,有说的不对的地方也希望大家能够指出来,谢谢!

    展开全文
  •   在学习《大话设计模式》的时候经常遇到多态,但什么多态?为什么要使用多态什么时候用多塔?多态是如何实现的?使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。 什么多态?   多态,...

      在学习《大话设计模式》的时候经常会遇到多态,但什么是多态?为什么要使用多态?什么时候用多态?多态是如何实现的?使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。

    什么是多态?

      多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。

    例:猪、狗、猫都属于动物类,我们将动物类作为父类,猪“哼哼叫”,狗“汪汪叫”,猫“喵喵叫”,猪、狗、猫三者都能叫,但三者都要通过重写父类的方法才能实现。

    为什么要使用多态?使用多态有什么好处?

      我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。

    代码重用,也称代码复用, 就是说你把一个功能写成一个模块, 以便再次需要相同功能的时候,可以直接使用,而不用重新开发。
    举例: 假如你的网站需要验证码, 你就可以把验证码这个功能单独提取出来以便复用。
    通常代码复用是通过类与对象来实现的, 这也是面向对象编程与面向过程编程最主要的区别之一。

      作为面向对象的三大特性之一,多态也有代码重用的功能,还有解决项目中紧耦合的问题,提高程序的可扩展性·。

    举例:添加一个子类,继承父类,重写父类的方法。至此,该程序的扩展性得到了提升,而又不需要查看源代码是如何实现的就可以扩展新功能。

    什么时候用多态?

    • 方法中的参数
        class Program
        {
            static void Main(string[] args)
            {
                Person p=new Person();
                Audi audi=new Audi();
                p.setDriver(audi);
                p.drive();
                SBenz benz=new SBenz();
                p.setDriver(benz);
                p.drive();
            }
        }
    
        public abstract class Driver
        {
            public abstract void run();
        }
    
        class SBenz : Driver
        {
            public override void run()
            {
                Console.WriteLine("大奔");
            }
        }
    
        class Audi:Driver
        {
            public override void run()
            {
                Console.WriteLine("奥迪");
            }
        }
    
        class Person
        {
            private Driver driver;
            public Person() { }
    
            public Person(Driver driver)
            {
                this.driver = driver;
            }
    
            public void drive()
            {
                driver.run();
            }
    
            public void setDriver(Driver driver)
            {
                this.driver = driver;
            }
        }
    
    • 方法的返回类型
        public class CarFactory
        {
            public static Driver createCar(string carName)
            {
                
                if (carName.Equals("Audi"))
                {
                    return new Audi();
                }
                else if (carName.Equals("Benz"))
                {
                    return new SBenz();
                }
                else
                {
                    Console.WriteLine("出门左拐");
                    return null;
                }
            }
        }
    

    多态是如何实现的?

    • 父类是抽象类,方法是抽象方法(没有方法体,也不能实例化),子类重写父类的方法
    • 父类中是虚方法(有方法体,能实例化),子类重写父类的方法

    小结

    • 虚方法一定要有方法体(哪怕只是大括号),抽象方法一定没有方法体
    • 虚方法可以被子类重写,抽象方法必须被子类重写
    • 如果我们不需要使用父类创建对象,它的存在只是为供子类继承。可以将父类写成抽象(关键字abstract)类,将父类的方法写成抽象方法,子类中的方法仍用关键字override重写
    • 抽象类不能被实例化
    • 多态是指类可以有多种形态,通过修改可以形成多个的实现方法。当子类从父类继承时,它会获得父类的所有方法、字段、属性和事件。若要更改父类的数据和行为,通常有两种选择,第一种是在子类的访问修饰符后加new,就是隐藏了基类(父类)的方法,第二种是在子类中重写父类的方法,更换方法里的内容。

      耐心点,坚强点,总有一天,你承受过的疼痛会有助于你,生活从来不会刻意亏欠谁,它给了你一块阴影,必会在不远的地方撒下阳光。

    展开全文
  • Java多态实现机制

    2015-03-28 21:51:58
    Java多态实现机制
    Java语言中,多态主要有以下两种表现方式:


    1、方法的重载。重载是指同一个类中有多个同名的方法,但这些方法有着不同的参数,因此在编译时就可以确定到底调用哪个方法,它是一种编译时多台。重载可以看作一个类中的方法多态性


    2、方法的覆盖。这个就不说了


    package test;
    
    class Base{
    	public Base(){
    		g();
    	}
    	public void f(){
    		System.out.println("Base f()");
    	}
    	public void g(){
    		System.out.println("Base g()");
    	}
    }
    class Derived extends Base{
    	public void f(){
    		System.out.println("Derived f();");
    	}
    	public void g(){
    		System.out.println("Derived g();");
    	}
    }
    public class Test{
    	public static void main(String[] args){
    		Base b=new Derived();
    		b.f();
    		b.g();
    	}
    	
    }
    

    程序运行结果:
    Derived g();
    Derived f();
    Derived g();

    在执行Base b=new Derived()语句时,会调用Base类的构造函数,而在Base的构造函数中,执行了g()方法,由于Java语言的多态特性,此时会调用子类Derived的g()方法,而非父类base的g()方法。

    Java语言中提供了两种用于多态的机制

    编译时多态和运行时多态。
    编译时多态是通过方法的重载实现的,运行时多态是通过方法的覆盖实现的
    展开全文
  • JAVA多态实现

    2019-11-25 20:06:00
    多态实现: 多态:一个函数名根据对象不同对应不同实现 1) 静多态(编译期多态/静态绑定)->函数重载 重载的条件:在一个类中,函数名相同,参数列表不同 2) 动多态(运行期多态/动态绑定) 发生动态绑定...
  • 什么多态多态实现方法是什么? 点击查看
  • 什么多态? 同一操作作用于不同的对象,可以不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。 为什么多态? "封装"通过合并特征和行为来创建新的数据类型。“实现...
  • 什么多态实现多态的机制是什么

    千次阅读 多人点赞 2018-10-30 22:13:00
    接口的多种不同的实现方式即为多态。 多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术。 我们在程序中定义的引用变量所指向的具体类型和通过该引用变量的方法调用在编程的时候并不确定,当处于...
  • C++ 多态实现

    2019-09-12 20:48:30
    多态 多态的含义为 一个事物的多种形态,在C++程序设计张,多态性... 参数多态:采用参数化模板,通过给出不同的类型参数,使的一个结构多种类型。如C++语言中的函数模板和类模板。如 C++语言中的函数模板和类模...
  • 多态实现的原理

    2017-03-15 18:33:52
    多态实现的原理
  • .net 多态实现

    2015-12-07 18:06:05
    通过继实现多态: 1、第一个父类,父类中存在一个Virtual方法,子类继承该父类,并使用override重写该父类中的Virtual方法 2、抽象类中中抽象方法,父类通过override实现抽象类中抽象方法通过使用abstract-...
  • 多态定义、多态实现、多态分类。

    千次阅读 2018-08-23 11:46:47
    1.多态定义:同一操作作用于不同的...实现多态有三种方式:虚方法,抽象方法,接口。   虚方法:子类重写父类中的方法,对父类中的方法进行覆盖。适用情况:父类中的方法对子类来说不适用,子类通过重写该方法,覆...
  • 所谓多态:定义时的类型和...Python的多态,就是弱化类型,重点在于对象参数是否指定的属性和方法,如果就认定合适,而不关心对象的类型是否正确。 Python伪代码实现Java或C#的多态 class F1(object): def show
  • 多态实现原理

    2013-09-08 17:31:30
    C++中多态实现原理怎样的? Q: 通过迟邦定技术(late binding)实现。 具体实现原理如下: 1. 基类中函数带virtual关键字,表示该方法为虚函数。 2. 子类继承基类,并对虚函数重写(亦可以不重写)。 3. 编译器...
  • C++多态实现机制

    2017-07-17 14:15:22
    而动态多态则是通过类的继承和虚函数来实现,当基类和子类拥有同名同参同返回的方法,且该方法声明为虚方法,当基类对象,指针,引用指向的是派生类的对象的时候,基类对象,指针,引用在调用基类的虚函数,实际上调...
  • 实现多态的两种方式 一、什么多态? 父类类型的变量指向子类创建的对象,使用该变量调用父类中一个被子类重写的方法,则父类中的方法呈现出不同的行为特征,这就是多态。 简单的来说编译时方法行为表现的是...
  • (2)多态实现的三个条件  继承、virtual重写、父类指针(引用)指向子类对象。 (3)多态的C++实现  virtual关键字,告诉编译器这个函数要支持多态;不要根据指针类型判断如何调用;而是要根据指针所指向的...
  • 多态实现的机制

    千次阅读 2018-08-28 10:47:35
    什么多态多态是C++编程时的一种特性,多态性即是对一个接口的多种实现多态可以分为静多态和动多态。所谓静多态就好比函数重载、模板,静多态是在函数编译阶段就决定调用机制,即在编译连接阶段就将函数的...
  • java基础:多态实现方式 很多地方都写着多态三要素是: 继承、重写、向上转型。 所以继承实现多态我理解了,那么用接口实现多态的呢,它并不符合多态三要素。很困惑,希望大佬来解答一下!
  • 在 JAVA多态用在解决什么问题

    千次阅读 2015-07-29 09:49:11
    在 JAVA多态用在解决什么问题? 2011-11-24 07:39wangjianr 分类:JAVA相关 | 浏览 3083 次 分享到: 2011-11-24 07:51 提问者采纳 其实多态是一种面向对象的设计思想...
  • 主要介绍了C#中多态现象和多态实现方法,较为详细的分析了多态的原理与C#实现多态的方法,以及相关的注意事项,需要的朋友可以参考下
  • Java多态实现机制是父类或接口定义的引用变量可以指向子类或实现类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的具体实现对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用...
  • java多态实现原理

    万次阅读 多人点赞 2016-07-22 16:46:24
    众所周知,多态是面向对象编程语言的重要特性,它允许基类的指针或引用...注意到在本文中,指针和引用互换使用,它们仅是一个抽象概念,表示和另一个对象的连接关系,无须在意其具体的实现。 Java 的实现方式 J
  • 多态实现为宠物喂食 题目如下 宠物饿了,主人需要为宠物喂食,使用多态实现该过程 不同宠物吃的东西不一样 不同宠物吃完东西后恢复健康值不一样 健康值达到100时,不需要继续喂食 实现过程 1.首先先建个宠物类...
  • 1. 多态分类 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名 动态多态: 派生类和虚函数实现运行时多态...3. 多态实现的前提 赋值兼容规则是指在需要父类对象的地方可以使用子类对象
  • 多态实现机制是什么

    千次阅读 2019-05-08 22:31:30
    多态是面向对象程序设计中代码重用的一个重要机制,它表示当同一个操作在不同对象时,会有不同的语义,从而会产生不同的结果,例如:同样是执行“+”操作,“3+4”用来实现正数相加,而“3”+“4”却实现了字符串的...
  • 接口的多种不同的实现方式即为多态。 2.多态性是允许你将父类对象设置成为一个或更多的他的子对象相等的技术。 3.我们在程序中定义的引用变量所指向的具体类型和通过改引用变量的方法调用在编程的时候并不确定,...
  • c++ 多态实现机制

    2015-04-24 20:48:42
    一篇讲得还可以的的多态实现机制的博文,先记录下来:http://blog.csdn.net/zyq0335/article/details/7657465

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 254,508
精华内容 101,803
关键字:

多态的实现会有什么问题