精华内容
下载资源
问答
  • 多态优点: 代码组织结构清晰 可读性强 利于前期和后期的扩展以及维护 对拓展开放,对修改关闭 #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;
    }
    
    展开全文
  • java多态优点之一就是提高了代码的扩展性(由多态保证) 用代码举个例子 class Demon_Animal{ public static void main(args[]){ Cat c = new Cat(); c.eat(); method(new Cat()); method(new Dog());...

    java多态的优点之一就是提高了代码的扩展性(由多态保证)

    用代码举个例子

    class Demon_Animal{
    	public static void main(args[]){
    		Cat c = new Cat();
    		c.eat();
    		method(new Cat());
    		method(new Dog());//错
    		
    		Animal a = new Cat();//不建议这么做
    	/**
    	*开发很少这样写
    	*	在创建对象时很少用父类引用指向子类对象
    	*	直接创建子类对象更方便,可以使用子类特有的属性和行为
    	*/
    	public static void method(Cat c){
    		c.eat();
    	}
    	public static void method(Dog d){
    		d.eat();
    	}
    	//and so on`````这样做太麻烦了,看下面这个方法
    
    	public static void method(Animal a){//当做参数时用多态,扩展性强
    		a.eat();
    		//a.catchMouse();错误
    		//如果把狗强转为猫就会出现类型转换异常ClassCastException
    		//Cat c = (Cat)a;
    		//c.eat();
    		//c.catchMouse();//若传入dog则错误
    		//instanseof  判断前边的引用是否是后边的数据类型
    		if(a instanceof Cat){
    			Cat c = (Cat)a;
    			c.eat();
    			c.catchMouse();
    		}elseif(a instanseof Dog){
    		}
    		//开发时很少调用子类特有的方法,一般是父类具有这些方法
    		子类重写这些方法,然后把父类类型当做参数,把子类传递进来
    		
    	}	
    }
    
    class Animal{
    	pubilc void eat(){
    		System.out.println("动物吃饭");
    	}
    	
    }
    class Cat extends Animal{
    	pubilc void eat(){
    		System.out.println("猫吃鱼")
    	}
    	public void catchMouse(){
    		System.out.println("捉老鼠")
    	}
    }
    class Dog extends Animal{
    	pubilc void eat(){
    		System.out.println("狗吃肉");
    	}
    	public void lookHome(){
    		System.out.println("狗看家");
    	}
    }


    展开全文
  • 多态

    2019-05-12 15:22:18
    概念: 声明父类变量来引用子类对象,...多态优点: 多态作用在形参上,可以接受更多的数据类型 多态作用在返回值类型上,可以返回更多的数据类型 多态特点: 多态情况下,子类和父类存在同名的成员属(静态和非...

    概念:

    声明父类变量来引用子类对象,或者声明接口变量来引用实现类对象

    使用多态前提:

    必须有继承或者实现条件下才能使用多态

     

    语法规则:

    父类的引用(变量)可以指向子类的对象

    可以将子类的对象赋值给父类类型的变量

    多态优点:

    1. 多态作用在形参上,可以接受更多的数据类型
    2. 多态作用在返回值类型上,可以返回更多的数据类型

    多态特点:

    1. 多态情况下,子类和父类存在同名的成员属(静态和非静态)性时,访问的是父类的成员属性
    2. 多态情况下,子类和父类存在同名的非静态成员函数时,访问的是子类的非静态函数
    3. 多态情况下,子类和父类存在同名的静态成员函数时,访问的是父类的静态函数
    4. 多态情况下,接口和实现类中存在函数,调用时访问的是实现类的函数

    多态的调用:

    1、向上转型

    Teacher teacher=new  Teacher();

    //new 出来的称为对象的类型

    //声明出来的 称之引用的类型

    一般的情况: 对象类型和引用的类型是同一种数据类型

    向上转型是指: 子类对象  赋予 父类的引用,向上转型是非常的安全

    Person person=new Teacher();

    2.向下转型

    向下转型: 把父类引用 赋予子类引用

        Student student=new Person();//绝对错误

    这是错误是Type mismatch: cannot convert from Person to Student 类型不匹配:无法从个人转换为学生

        Student student2= (Student) person ;
            student2.home();//绝对错误

    这是错误是Teacher cannot be cast to duotai.Student    老师不能投给多台,学生

    Person person1=new Student();
    Student student1= (Student) person1 ;//
    //向下转型不安全,能否转型成功取决于父类引用中保存的是哪个子类对象
    student1.home();

    必须判断父类引用中到底保存的是哪个类型的对象才可以向下转型,否则报错

    instanceof

    nstanceof 如果是,返回 ture 否则是false

    写法格式:

    1. Person person2 =new Teacher();
    2.         if(person2 instanceof Teacher ){
    3.             Teacher teacher1 = (Teacher)person2;
    4.             teacher1.home();
    5.             
    6.         } 

    代码如下:

    public class Person {
    	public String name;
    	public String job;
    	public int age;
    	public char sex;
    	
    	public void present() {
    		System.out.println("人高高兴兴地度过每一天");
    	}
    	public void work() {
    		System.out.println("对工作认真地负责");
    	}
    }
    
    
    public class Teacher extends Person {
    
    	public void shool() {
    			super.name="王五";
    		job="师范大学";
    		System.out.println(name+"在"+job+"教Java课");
    	}
    	public void home() {
    		super.name="王五";
    		System.out.println(name+"的家家庭充满知识的气氛");
    	}
    }
    
    public class Student extends Person{
    	String name="小花";
    	protected void operating() {
    		age=17;
    		System.out.println(name+"在"+age+"上高三");
    	}
    	public void home() {
    		
    		System.out.println(name+"在家庭看书");
    	}
    
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//	向上转型
    		Teacher teacher=new  Teacher();
    		teacher.shool();
    		//向下转型 把父类引用 赋予子类引用
    		// Type mismatch: cannot convert from Person to Student
    		Student student=new Student() ;
    		
    		//Dog dog = (Dog)animal;  //向下转型
    		student.operating();
    		Person person=new Teacher();
    		person.work();
    		
    		Person person1=new Student();
    		Student student1= (Student) person1 ;
    		student1.home();
    		
    		//instanceof 如果是,返回 ture 否则是false
    		Person person2 =new Teacher();
    		if(person2 instanceof Teacher ){
    			Teacher teacher1 = (Teacher)person2;
    			teacher1.home();
    			
    		} 
    
    	}
    	
    }
    

     

    展开全文
  • 多态优点

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

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

    展开全文
  • 多态优点类调用者对类的使用成本进一步降低.能够降低代码的 "圈复杂度", 避免使用大量的 if - else可扩展能力更强2.方法重写什么是重写重写和重载的区别 1.多态优点 类调用者对类的使用成本进一步降低. 封装是...
  • 多态是一项让程序员“将改变的事物和未变的事物分离开来的重要技术”。 改变的事物可能是添加了新的子类或父类和子类添加了新的方法,未变的事物可能是对基类的调用如 tune(Instrument i)方法调用,传入i的可能是...
  • 备忘:多态优点

    2018-07-10 10:22:09
    本段直接摘抄廖雪峰关于多态的的介绍: 新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行,原因就在于多态多态的好处就是,放...
  • 多态优点与弊端

    千次阅读 2017-03-11 15:51:20
    多态的好处:A:提高了代码的维护性(继承保证) B:提高了代码的扩展性(由多态保证)多态的弊端不能使用子类的特有功能。其实也可以通过转型使用。对象间的转型问题:向上转型:Fu f = new Zi();向下转型:Zi z = (Zi)f...
  • using System;using System.Collections.Generic;using System.Text;/*多态简化了代码的维护* 如果不是多态的时候*/namespace ConsoleApplication1{public class Student { private string name; private ...
  • JAVA里的多态特性优点

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

    2020-07-30 12:25:03
    C++多态总结(动态)多态概念(动态)多态底层(动态)多态优点纯虚函数和抽象类虚析构和纯虚析构 多态是C++面向对象三大特性封装、继承、多态之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态,...
  • JAVA多态

    2020-03-04 22:20:50
    多态优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 多态存在的必要条件 继承 重写 父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;...
  • Java多态

    2020-02-18 16:24:53
    多态的概述和及其代码体现 ...多态优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 代码实现: public class demo_Animal { public static void main(String[] args) { Cat cat1 = new ...
  • 多态优点: 1. 消除类型之间的耦合关系 2. 可替换性 3. 可扩充性 4. 接口性 5. 灵活性 6. 简化性 多态存在的三个必要条件 继承 重写 父类引用指向子类对象 比如: Parent p = new Child...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,149
精华内容 859
关键字:

多态优点