精华内容
下载资源
问答
  • 多态有
    2020-07-31 07:29:29

    继承是子类获得父类的成员,重写是继承后重新实现父类的方法。重载是在一个类里一系列参数不同名字相同的方法。多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。

    更多相关内容
  • python多态理解(多态有啥用)

    千次阅读 多人点赞 2020-03-11 11:04:45
    什么是多态多态顾名思义多种状态,在python中,不同的对象调用同一个接口,表现出不同的状态,称为多态。 class Duck(): def who(self): print("I am a duck") class Dog(): def who(self): print("I am a ...

    什么是多态?
    多态顾名思义多种状态,在python中,不同的对象调用同一个接口,表现出不同的状态,称为多态。

    class Duck():
        def who(self):
            print("I am a duck")
    
    class Dog():
        def who(self):
            print("I am a dog")
    
    class Cat():
        def who(self):
            print("I am a cat")
    if __name__ == "__main__":
        duck=Duck()
        dog=Dog()
        cat=Cat()
        duck.who()
        dog.who()
        cat.who()
    

    输出结果:

    I am a duck
    I am a dog
    I am a cat
    

    以上代码是多态吗?虽然不同的对象调用同一个接口表现出不同状态,但是!!这不是多态!要实现多态有两个前提:
    1.继承:多态必须发生在父类与子类之间
    2.重写:子类重写父类方法

    把以上代码进行修改,使之继承父类,才实现多态,如下:

    class Animal():
        def who(self):
            print("I am an Animal")
    class Duck(Animal):
        def who(self):
            print("I am a duck")
    
    class Dog(Animal):
        def who(self):
            print("I am a dog")
    
    class Cat(Animal):
        def who(self):
            print("I am a cat")
    if __name__ == "__main__":
        duck=Duck()
        dog=Dog()
        cat=Cat()
        duck.who()
        dog.who()
        cat.who()
    

    多态有什么用?
    其实以上代码实际貌似没啥用,为什么一定要去定义通过同一个函数名?我定义who1,who2,who3不可以吗?代码量也一样啊!
    其实真正体验出多态好处的代码一般是这样写的

    class Animal():
        def who(self):
            print("I am an Animal")
    class Duck(Animal):
        def who(self):
            print("I am a duck")
    
    class Dog(Animal):
        def who(self):
            print("I am a dog")
    
    class Cat(Animal):
        def who(self):
            print("I am a cat")
    
    def func(obj):
        obj.who()
    
    if __name__ == "__main__":
        duck=Duck()
        dog=Dog()
        cat=Cat()
        func(duck)
        func(dog)
        func(cat)
    

    仅仅需要一个函数,就可以把不同对象的who函数表现出来了。这就增加了程序的灵活性,以不变应万变,不管你类中的who()写得如何得天花乱坠,我都可以用一个统一的形式来调用。另外,它增加了程序的可扩展性,不管是我们或者调用者,如果想增加新的功能,都不需要修改原来的代码。
    例如,我想新增一个bird类,仅需增加以下代码,无需修改原来的。

    class Bird(Animal):
        def who(self):
            print("I am a bird")
    

    对于调用者,也仅需增加以下代码,无需修改原来的。

    bird=Bird()
    func(bird)
    

    所以说多态有什么用?一是增加程序的灵活性,二是增加程序的可扩展性

    以上,菜鸟一枚,如有不当指出,请指出。

    展开全文
  • 什么是多态?多态有什么用途? 什么是多态?多态有什么用途? 什么是多态?多态有什么用途? 什么是多态?多态有什么用途?
  • 什么是多态?多态有什么好处?

    千次阅读 2020-07-11 10:56:22
    同一操作作用于不同的对象,可以不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。 为什么用多态? "封装"通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将...

    什么是多态?

    同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。

    为什么用多态?

    "封装"通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”,把接口和实现分离开来。这种类型的组织机制对那些拥有过程化程序设计背景的人来说,更容易理解,而多态的作用则是消除类型之间的耦合关系。继承允许将对象视为他自己本身的类型或其基本类型来加以处理。多态方法允许一种类型表现出于其他类型之间的区别,只要他们都是从同一基类导出即可,这种区别是根据方法行为的不同而表现出来的,虽然这些 方法都可以通过同一个基类来调用。

    多态的应用:

    1. 转型。即只要用一个基类的引用指向子类对象时,该对象会自动提升到基类的类型。
    2. 动态绑定,也就是说在如果一个派生类上升到基类之后,当调用基类中的方法时,如果该方法在派生类中被重写了,默认会调用派生类中的重写方法。
    class Cycle {
    	private String name = "Cycle";
    
    	public static void travel(Cycle c) {
    		System.out.println("Cycle.ride()" + c);
    	}
    
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Unicycle extends Cycle {
    	private String name = "Unicycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Bicycle extends Cycle {
    	private String name = "Bicycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Tricycle extends Cycle {
    	private String name = "Tricycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    public class Demo1 {
    	
    	public static void ride(Cycle c) {
    		c.travel(c);
    	}
    	public static void main(String[] args) {
    		Unicycle unicycle = new Unicycle();
    		Bicycle bicycle = new Bicycle();
    		Tricycle tricycle = new Tricycle();
    		ride(unicycle);
    		ride(bicycle);
    		ride(tricycle);
    	}
    }

     

    展开全文
  • 使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。 什么是多态?   多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。 例:猪、狗、猫都...

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

    什么是多态?

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

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

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

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

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

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

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

    什么时候用多态?

    • 方法中的参数
        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,就是隐藏了基类(父类)的方法,第二种是在子类中重写父类的方法,更换方法里的内容。

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

    展开全文
  • C++多态有哪几种方式?

    千次阅读 2019-01-08 16:53:20
    (1)静态多态(重载,模板) 是在编译的时候,就确定调用函数的类型。 (2)动态多态(覆盖,虚函数实现) 在运行的时候,才确定调用的是哪个函数,动态绑定。运行基类指针指向派生类的对象,并调用派生类的函数。 ...
  • 主要介绍了C#中多态、重载、重写区别,采用实例较为通俗易懂的分析了多态、重载的重写的概念与用法,对于C#初学者非常不错的借鉴价值,需要的朋友可以参考下
  • 【超经典】Java多态有什么好处?怎样用?

    万次阅读 多人点赞 2015-10-06 23:05:01
    多态的表现形式方法重载,方法改写,多态变量和泛型。重载是一种静态的多态性,在程序编译时确定被调用的方法,称为早绑定。而多态变量和改写相结合之后,方法的调用在运行时才能确定,是动态的多态性,称为晚绑定...
  • 今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客...
  • 1. 多态 方法或对象具有多种形态,是OOP(面向对象的编程)的三大特征, 是建立在封装和继承基础之上。 2. 多态具体体现 1. 方法多态 (1)重载体现多态 (2)重写体现多态 2. 对象 (1)对象的编译类型和运行类型...
  • 从Java多态到策略模式

    2021-01-20 03:33:35
    先来复习下java多态:java多态指的是父类引用指向子类对象,不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。  接下来我们再说下什么叫策略模式:将每一个算法封装到...
  • 虽然我们经常把多态混为一谈,但实际上 四种不同类型的多态。在开始正式的子类型多态的细节讨论前,然我们先来看看普通面向对象中的多态。Luca Cardelli和Peter Wegner("On Understanding Types, Data Abstraction...
  • java多态有两种情况:重载和覆写 在覆写中,运用的是动态单分配,是根据new的类型确定对象,从而确定调用的方法; 在重载中,运用的是静态多分派,即根据静态类型确定对象,因此不是根据new的类型确定调用的...
  • 多态的具体体现与心得。
  • 多态 多态分为动态多态和静态多态。 静态多态:在运行前就决定函数调用的地址,也就是地址早绑定。 静态多态包括了:函数重载,运算符重载,和重定义。 分别阐述一下: 函数重载首先在同一个作用域当中,函数的名字...
  • Java多态有编译时多态和运行时多态

    千次阅读 2016-09-04 10:53:39
    多态有编译时多态和运行时多态。  第一个是通过方法重载实现;  第二个是通过方法覆盖实现(子类覆盖父类方法)。  第一种就是我们调用方法是不用区分参数类型,程序会自动执行相应方法,如:加法运算,可以使int...
  • C++类的多态练习(Class polymorphism exercise)
  • java中关于多态的定义并没有一个准确的说法,这也是由于它本身的内容就很复杂。java中这种复杂的机制还有很多,往往需要我们花费大量的时间去研究。接下来主要来说一下它的用途,一起来看看吧。首先,我们需要知道的...
  • 使用多态的好处

    2022-07-07 11:10:58
  • c++ 多态详解

    2022-05-02 15:58:41
    c++多态详解
  • 什么是多态,Python多态及用法详解 在面向对象程序设计中,除了封装和继承特性外,多态也是一个非常重要的特性,本节就带领大家详细了解什么是多态。 我们都知道,Python 是弱类型语言,其最明显的特征是在使用变量...
  • 上次已经为大家介绍过java中多态的意义是什么的主要内容了。今天为大家解析一下java中多态的机制,会通过实际的代码来为大家解析,一起来了解一下吧。首先说一些,多态的机制本质上多态分两种:1. 编译时多态(又称...
  • 这个就是理解错误了,多态的表现形式远远不止重写方法。 多态可以分为变量的多态,方法的多态和类的多态 变量的多态的表现形式是泛型(Generic),方法的多态就是我现在理解的多态(包括override and overload) 类...
  • Java——多态

    2020-12-21 19:51:44
    Java——多态 多态的特性 1.可替换性(substitutability)。多态对已存在代码具有可替换性。 例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环, 也同样工作。 2.可扩充性(extensibility)。多态对代码...
  • 多态有什么用?通俗一点来讲-> 多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。当多态应用形参类型的时候,可以接受更多的类型。当多态用于返回值...
  • c++中的动态多态介绍及应用 1.多态的基本概念 **多态是c++面向对象的三大特性之一,那么什么是多态呢?**多态分为两类:静态多态和动态多态 ...//1 继承关系 //2 子类重写父类中的虚函数 virtual class Animal { pub
  • 前言  的C++不再是个单纯的“带类的C”语言,它已经发展成为一个多种次语言所组成的语言集合,其中泛型编程与基于它的STL是C++发展中为出彩的那...对于相关功能的对象集合,我们总希望能够抽象出它们共有的功能集
  • 实现多态的两种方式 一、什么是多态? 父类类型的变量指向子类创建的对象,使用该变量调用父类中一个被子类重写的方法,则父类中的方法呈现出不同的行为特征,这就是多态。 简单的来说编译时方法行为表现的是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 434,965
精华内容 173,986
关键字:

多态有