精华内容
下载资源
问答
  • 多态优点: 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 对拓展开放,对修改关闭 #include <iostream> #include <string> using namespace std; //普通写法 class Calculator { ...

    多态的优点:

    • 代码组织结构清晰
    • 可读性强
    • 利于前期和后期的扩展以及维护 对拓展开放,对修改关闭
    #include <iostream>
    #include <string>
    using namespace std;
    
    //普通写法
    class Calculator
    {
    public:
        int m_num1;
        int m_num2;
        Calculator(int num_1, int num_2)
        {
            m_num1=num_1;
            m_num2=num_2;
        }
        int getResult(string oper)
        {
            if(oper=="+")
                return m_num1+m_num2;
            else if(oper=="-")
                return m_num1-m_num2;
            else if(oper=="*")
                return m_num1*m_num2;
            else if(oper=="/")
                return m_num1/m_num2;
            else
            {
                cout<<"请输入“+ - * /”四则运算:";
                return NULL;
            }
        }
    };
    
    //多态写法
    class AbstractCalculator
    {
    public:
        int m_num1;
        int m_num2;
        virtual int getResult()
        {
            return 0;
        }
    };
    
    class AddCalculator:public AbstractCalculator
    {
        int getResult()
        {
            return m_num1+m_num2;
        }
    };
    class SubCalculator:public AbstractCalculator
    {
        int getResult()
        {
            return m_num1-m_num2;
        }
    };
    class MulCalculator:public AbstractCalculator
    {
        int getResult()
        {
            return m_num1*m_num2;
        }
    };
    class DevCalculator:public AbstractCalculator
    {
        int getResult()
        {
            return m_num1/m_num2;
        }
    };
    
    void test01()   //普通写法
    {
        Calculator c(10,10);
        cout<<c.getResult("+")<<endl;
        cout<<c.getResult("-")<<endl;
        cout<<c.getResult("*")<<endl;
        cout<<c.getResult("/")<<endl;
        cout<<c.getResult("&")<<endl;
    }
    void test02()   //多态写法
    {
        AbstractCalculator *abc=new AddCalculator;
        abc->m_num1=10;
        abc->m_num2=10;
        cout<<abc->getResult()<<endl;
        delete abc;
    
        abc=new SubCalculator;
        abc->m_num1=10;
        abc->m_num2=10;
        cout<<abc->getResult()<<endl;
        delete abc;
    
        abc=new MulCalculator;
        abc->m_num1=10;
        abc->m_num2=10;
        cout<<abc->getResult()<<endl;
        delete abc;
    }
    int main()
    {
    //    test01();
        test02();
        return 0;
    }
    
    展开全文
  • 多态优点

    2019-07-27 11:52:13
    主要有以下优点: 可替换性:多态对已存在代码具有可替换性 可扩充性:增加新的子类不影响已经存在的类结构 接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。 灵活性 简化...

    允许不同类对象对同一消息做出响应,即同一消息可以根据发送对象的不同而采用多种不同的行为方式(发送消息就是函数调用)。主要有以下优点:
    可替换性:多态对已存在代码具有可替换性
    可扩充性:增加新的子类不影响已经存在的类结构
    接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的。
    灵活性
    简化性

    展开全文
  • 优点 提高程序扩展性 缺点 多态不能访问子类特有的功能 首先 我们先创建6个类 cat dog pig ff(方法) dongwu(父类) cz(操作使用) 定义一个父类的方法 package duotai; public class dongwu { public void chi...

    今天,我们一起来学习以下多态。
    先说一下

    优点

    提高程序扩展性

    缺点

    多态不能访问子类特有的功能

    首先 我们先创建6个类

    1. cat
    2. dog
    3. pig
    4. ff(方法)
    5. dongwu(父类)
    6. cz(操作使用)

    定义一个父类的方法

    package duotai;
    
    public class dongwu {
    
        public void chi(){
            System.out.println("啥都吃");
        }
    
    }

    子类

    package duotai;
    
    public class cat extends dongwu{
        //重新父类方法
        @Override
        public void chi() {
            System.out.println("猫吃鱼");
        }
    }
    package duotai;
    
    public class dog extends dongwu{
        @Override
        public void chi() {
            System.out.println("吃骨头");
        }
        public void zy(){
            System.out.println("看大门");
        }
    }
    package duotai;
    
    public class pig extends dongwu{
        @Override
        public void chi() {
            System.out.println("猪吃青菜");
        }
    }

    第一种写法 不方便 可读性低

    package duotai;
    
    public class cz {
        //定义一个操作类
    
        public void chi(cat x){      // cat x=new cat();
            //这个方法里需要猫类型的对象
            x.chi();
        }
    
        public void chi(dog z){     // dog z=new dog();
            z.chi();
        }

    第二种

     public void chi(dongwu a){
     //以父类动物为参数
            a.chi();
            //dongwu a=new cat()
            //dongwu a=new dog()
            //dongwu a=new pig()
    //        a.zy();  不能访问子类特有的功能
        }

    首先创建cz类的对象 在cz类的chi方法中 需要一个变量进行传递。以c创建实例对象猫的时候,c就成了一个实例。
    在cz类的方法中缺少一个动物的变量,
    所以直接以cz类的对象名去调用chi方法+(实例对象)
    就可以输出对应的方法输出语句

    package duotai;
    
    public class ff {
        public static void main(String[] args) {
            cz z=new cz();
            //创建操作对象
    
            cat c=new cat();
            //创建猫的对象
    
            z.chi(c);
            //把猫的对象传递到方法里
    
            dog v=new dog();
            z.chi(v);
            //创建狗的对象
    
            pig b=new pig();
            z.chi(b);
        }
    }
    展开全文
  • JAVA里的多态特性优点

    2020-06-02 18:09:47
    多态(Polymorphism)是Java中十分重要的一个特性。 它通过创建“父与子”式的对象来实现Java的高耦合性。 例如 父类 引用= new 子类 下面通过一个例子介绍多态的好处。 首先建立一个电脑类为父类。下面展示一些 ...

    多态(Polymorphism)是Java中十分重要的一个特性。
    它通过创建“父与子”式的对象来实现Java的高耦合性。
    例如 父类 引用= new 子类
    下面通过一个例子介绍多态的好处。
    首先建立一个电脑类为父类。下面展示一些 内联代码片

    public class Computer {
        public void price(){
    
        }
    }
    
    

    再建一个苹果电脑类extends 电脑类

    public class Apple extends Computer {
        //override the price method
        public void price(){
            System.out.println(9999);
        }
    }
    
    

    再建一个华为电脑类extends 电脑类

    public class Huawei {
        //override the price method
        public void price(){
            System.out.println(8888);
        }
    }
    

    再写一个消费者类

    public class Customer {
        public void buy(Apple a){
            System.out.print("You need pay: ");
            a.price();
        }
        public void buy(Huawei a){
            System.out.print("You need pay: ");
            a.price();
        }
    }
    
    

    最后为一个测试类

    public class Test {
        public static void main(String[] args) {
            //This method not use upcasting, so it don't show the polymorphism
            Apple apple=new Apple();
            Huawei huawei=new Huawei();
            Customer jack=new Customer();
            jack.buy(apple);
            jack.buy(huawei);
        }
    }
    

    结果为

    You need pay: 9999
    You need pay: 8888
    

    以上方法并没有使用多态,我们在实际工作中如果添加一个新类时,不但需要增加一个新类,还需要去Customer类里overload一个参数为新类的方法,需要改的地方多容易发生错误。因此我们需要使用多态的特性。即用创建父类对象但是引用却是去指向堆内存的一个子类对向。
    用户类直接改为以下为代码

    public class Customer {
        public void buy(Computer a){
            System.out.print("You need pay: ");
            a.price();
        }
    }
    

    这样我们建新类时就不需要修改用户类参数类型了
    测试类为:

    public class Test {
        public static void main(String[] args) {
            //This method not use upcasting, so it don't show the polymorphism
            Computer apple=new Apple();
            Computer huawei=new Huawei();
            Customer jack=new Customer();
            jack.buy(apple);
            jack.buy(huawei);
        }
    }
    

    结果依旧一样j

    You need pay: 9999
    You need pay: 8888
    
    展开全文
  • 多态优点和弊端

    2021-09-16 11:27:59
    1.优点 提高了代码的维护性(继承保证) 提高了代码的扩展性(由多态保证) 2.弊端 不能访问子类特有的成员变量和成员方法 解决方法:把父类的引用强制转换为子类的引用。(向下转型) 案例演示 public class MyTest...
  • 多态多态的好处(扩展性)

    万次阅读 多人点赞 2018-08-14 09:41:51
    多态 1、多态:同一个对象,在不同时刻体现出来的不同状态。 2、多态的前提:1)要有继承关系;2)要有方法重写;3)要有父类引用指向子类`Fu f= new Zi(); 例如,动物 d= new 狗( ),形参实参形式的(形参父类...
  • 封装、继承、多态的优缺点

    千次阅读 2020-05-26 09:23:02
    继承:使子类拥有父类非private的属性和功能,子类还具有自己的属性和功能,同时子类还可以改写父类中的功能(方法重写、与多态有关) 继承的好处: (1)代码共享,减少创建类的工作量(每个子类都具有父类的属性...
  • 学python的我,前几天有一个疑问,什么是python的鸭子类型。今天看了几篇文章感悟很深,记录一下这个... 而我们编辑一个像run_2这种方法,就叫多态。因为我们只需注意传入类型为Animal类型的,而不用管调用的细节。
  • 多态的好处

    千次阅读 2018-07-29 00:35:21
    多态有什么好处? 有两个好处: 1. 应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承  2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容...
  • 文章目录多态的定义格式多态中成员变量的使用特点成员方法的使用特点使用多态的好处 面向对象三大特点:分装性,继承性,多态性。extends继承或者implements接口的实现,是多态性的前提。 一个对象既是子类又是父类...
  • 多态

    2019-05-27 18:25:55
    面向对象程序涉及的三个特点:封装、继承、多态。 继承:继承关系使一个子类继承父类的特征,并且附加一些新特征。子类是它的父类的特殊化,每个子类的实例都是其父类的实例,但反过来不成立。例如每个圆都是几何...
  • 在面向对象的程序设计中,使用多态能够增强程序的可扩充性,即程序需要修改或增加功能时,只需改动或增加较少的代码。此外,使用多态也能起到精简代码的作用。本节通过游戏实例来说明多态的作用。 游戏程序实例 游戏...
  • 看了这个,我终于知道了为什么要用多态了 看了大量的资料和视频之后,我终于搞清了多态的作用了,废话不多说,直接上干货! 多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态的作用: 可以...
  • 面向对象—多态 ———————————————— 1. 2. 3.
  • 优点 1.提高代码的维护性(由继承保证):上面修改了下面也跟着修改。 2.提高了代码的延展性(由多态保证)。 3.可以当做形式参数,可以接受任何类型的子类对象。 缺点 不能使用子类特有的属性和行为 关键字...
  • 备忘:多态优点

    2018-07-10 10:22:09
    本段直接摘抄廖雪峰关于多态的的介绍: 新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行,原因就在于多态多态的好处就是,放...
  • java代码-多态优点,充分利用子类方法的重写
  • 多态优点: 1. 消除类型之间的耦合关系 2. 可替换性 3. 可扩充性 4. 接口性 5. 灵活性 6. 简化性 多态存在的三个必要条件 继承 重写 父类引用指向...
  • c++的模板是个很强很暴力的东西,可以轻松地模拟多态。下面举个例子: ==================================================================== #include #include using namespace std; class StarDecorator//...
  • Java 多态

    千次阅读 多人点赞 2016-11-17 00:09:26
    Java 多态 多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口,使用不同的实例而执行不同操作,如图所示: 多态性是对象多种表现形式的体现。 现实中,比如我们按下 ...
  • (1)编译时多态/静态联编 指联编工作在编译阶段完成,即在编译阶段确定了程序中的操作调用与执行该操作的代码间的关系,基于指向对象的指针类型或引用类型。 (2)运行时多态/动态联编 指联编在程序运行时动态进行,对...
  • 多态 1.多态 代码执行过程中呈现的多种形式 java分为编译时期、运行时期 编译时多态---在编译时期绑定代码 体现形式—重载 public void m(){} public void m(int i)...
  • using System;using System.Collections.Generic;.../*多态简化了代码的维护* 如果不是多态的时候*/namespace ConsoleApplication1{public class Student { private string name; private strin...
  • java多态优点之一就是提高了代码的扩展性(由多态保证) 用代码举个例子 class Demon_Animal{ public static void main(args[]){ Cat c = new Cat(); c.eat(); method(new Cat()); method(new Dog());...
  • 1、什么是多态?  父类指针指向子类对象,运行时期调用方法的时候,根据方法拥有者的真实类型,确定调用哪个方法。 2、如何实现多态?  要实现多态,需要加一个中间层,暴露父类的方法,内部根据指针的真实类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,231
精华内容 22,092
关键字:

多态优点