精华内容
下载资源
问答
  • 多态概念

    2017-05-15 16:23:00
    这是我们最后一个概念,也是最重要的知识点。 多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用) 实现多态的技术称为:动态...

    什么是多态

    1. 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。
    2. 多态的定义:指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)
    3. 实现多态的技术称为:动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。
    4. 多态的作用:消除类型之间的耦合关系。
    5. 现实中,关于多态的例子不胜枚举。比方说按下 F1 键这个动作,如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;如果当前在 Word 下弹出的就是 Word 帮助;在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

    下面是多态存在的三个必要条件,要求大家做梦时都能背出来!

    多态存在的三个必要条件
    一、要有继承;
    二、要有重写;
    三、父类引用指向子类对象。

     多态的好处

    1.可替换性(substitutability)。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。
    2.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。
    3.接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3 所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如Circle和Sphere为了实现多态,完善或者覆盖这两个接口方法。
    4.灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。
    5.简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    转载于:https://www.cnblogs.com/zhj1993/p/6856972.html

    展开全文
  • C# 多态概念

    2012-12-05 15:35:42
    C# 中 多态概念,不同对象对于同一个方法实现不同的效果
  • 主要介绍了进一步理解Java中的多态概念,是Java入门学习中的基础知识,需要的朋友可以参考下
  • Java多态概念与应用

    多人点赞 2021-03-07 12:33:28
    1.1 多态概念 多态指的是同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,很难理解。没关系,接下来将用一个小demo带你了解多态的概念和优点。 提示:文章写完后,目录可以自动生成,如何生成可参考...

    多态

    多态指的是同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,很难理解。没关系,接下来我将全面带你了解Java多态。


    前言

    多态作为Java三大特性之一,其重要性相信也不用我多说吧。今天这篇帖子就将全面为你介绍多态的概念和应用

    一、多态是什么?

    多态是指同一个行为具有多个不同表现形式或形态的能力。是不是感觉很抽象,没事,接下来就让我用一个demo带你了解什么是多态吧。

    1. 代码思考

    新建person类

    public class Person {
        public String total(){
            return "this person class";
        }
    }
    
    

    新建Student类

    public class Student extends Person {
        @Override
        public String total(){
            return "这是 student class";
        }
    }
    

    2.输出的结果是什么?

    public class Demo{
        public static void main(String[] arg){
            Person student = new Student();
            System.out.println(student.total()); 
            // 这是 student class
        }
    }
    

    为什么对象声明是Person类,但输出的却是Student 类的方法。这是多态的关键所在:
    Java实例方法调用是基于运行时实际类型动态调用,而并非引变量本身

    3.多态需要满足要求

    将上述多态代码,抽离出特点。我们可以得到多态需要满足条件:

    1. 子类继承父类
    2. 子类重写父类方法
    3. 子类对象指向父类声明(最关键一点)

    那有的同学就会疑问了,那我直接使用子类引用不就行了吗,为什么要多此一举。那不妨来看一下接下来这一段代码。

    4.多态的应用

    public class Demo{
        public static void main(String[] arg){
            Person person = new Person();
            Person student = new Student();
            getClassName(person); // 这是 person class
            getClassName(student); // 这是 student class
        }
        public static void getClassName(Person person){
            System.out.println(person.total());
        }
    }
    

    这就是多态的巧妙与应用了,这里我们可以看到,getClassName需要的参数是Person 类型。但当我们传入的是student 对象时,程序依旧运行正确输出了。

    在实际开发中,代码和方法的量级很为庞大。如果某一天客户有一个新的需求让你添加一个新的功能,你需要重写一个新类,然后在调用接口处重新加一个方法,用于调用你新写的类中的方法。而多态的出现,让你只需新建子类,重写父类方法,也不需要新增调用接口。而且最主要的是也不用改写前辈的可能随时引爆的代码了(手动狗头)。

    因此多态的出现也很大程度的降低了代码冗余性,提高了代码的复用性,也降低了出错的可能性,而且也方便管理。

    5 多态中父类声明对象只能调用所声明类中的方法

    public class Student extends Person {
        @Override
        public String total(){
            return "这是 student class";
        }
    
        public String util(){
            return "这是 util 方法";
        }
    }
    

    向Student类中新建方法util(),那此时student变量可以调用util()吗,答案是不能。
    在这里插入图片描述
    此时我们可以看到,在变量student方法栏中没有新建的util()方法。这是因为声明引用为student父类,所以,多态中父类声明对象只能调用所声明类中的方法。

    二、多态进阶应用

    1.问题

    某企业A类经理纳税13%,B类高管纳税8%,C类员工享受补贴不纳税。请你设计一个程序计算改企业所有员工需要纳税金额(使用多态)?

    你可以先动手实现一下

    2.代码实现

    新建Employee类,用于定义接口,即父类。

    public class Employee {
        double tax = 0;
        public Employee(int tax){
            this.tax = tax;
        }
        public double getTax() {
            return 0;
        }
    }
    

    分别新建 Management、Senior、Normal 继承 Employee,代表不同类型员工。

    public class Management extends Employee {
        public Management(int tax){
            super(tax);
        }
        @Override
        public double getTax() {
            return  tax*0.13;
        }
    }
    
    public class Senior extends Employee {
        public Senior(int tax) {
            super(tax);
        }
        @Override
        public double getTax(){
            return tax * 0.08;
        }
    }
    
    public class Normal extends Employee{
        public Normal(int tax) {
            super(tax);
        }
        @Override
        public double getTax(){
            return 0;
        }
    }
    
    

    定义接口,计算所有员工的纳税金额总和。

    public class Demo{
        public static void main(String[] arg){
            Employee[] employeeTax = new Employee[]{
                    new Management(23414),
                    new Senior(1234),
                    new Normal(3478)
            };
            System.out.println(getEmployeeTaxSum(employeeTax));
        }
        public static double getEmployeeTaxSum(Employee[] employee){
            double taxNum = 0;
            for (Employee eTax : employee){
                taxNum += eTax.getTax();
            }
            return taxNum;
        }
    }
    

    总结

    以上就是今天要讲的内容,本文全面介绍了Java多态的概念、特性、使用条件以及应用场景。相信仔细阅读这篇文章,你就能搞清Java多态。

    如果你觉得这篇帖子不错,可以关注我,我将定期更新Java知识。

    展开全文
  • C++多态概念和意义

    2020-09-04 10:12:31
    2、C++如何支持多态概念 3、多态内部运行剖析 4、多态的意义 5、修改示例代码 四、静态联编和动态联编 五、小结 一、什么叫重写 1、子类中可以重定义父类中已经存在的成员函数; 2、这种重定义发生在继承中...

    目录

    一、什么叫重写

    二、面向对象期望的重写

    1、示例分析

    2、所期望的重写

    三、多态的概念和意义

    1、多态的概念

    2、C++如何支持多态概念

    3、多态内部运行剖析

    4、多态的意义

    5、修改示例代码

    四、静态联编和动态联编

    五、小结


    一、什么叫重写

    1、子类中可以重定义父类中已经存在的成员函数;

    2、这种重定义发生在继承中,叫做函数重写;

    3、函数重写是同名覆盖的一种特殊情况。

    二、面向对象期望的重写

    先来验证个小示例:

    #include <QCoreApplication>
    #include <iostream>
    #include <QDebug>
    
    using namespace std;
    
    class Parent
    {
    
    public:
    
        void Printfln()
        {
            std::cout << "Parent: void Printfln()..." << std::endl;
        }
    };
    
    class Child : public Parent
    {
    public:
    
        void Printfln()
        {
            std::cout << "Child: void Printfln()..." << std::endl;
        }
    };
    
    void run(Parent *p)
    {
        p->Printfln();
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Parent p;
        Child c;
    
        run(&p);
        run(&c);
    
        return a.exec();
    }
    

    1、示例分析

    1、结果:结果是调用两次run函数打印的结果相同;

    2、分析:

    (1)编译期间,编译器只能根据指针的类型判断所指向的对象;

    (2)根据赋值兼容性原则,编译器认为父类指针指向的是父类对象;

    (3)run函数中的指针p,编译器不可能知道它指向的究竟是什么,但是编译器没理由报错,编译器认为最安全的做法就是调用父类Printfln()函数,因为父类和子类都有相同的Printfln()函数;

    (4)因此,编译器结果只可能是调用父类定义的同名函数。

    2、所期望的重写

    面向对象的期望重写行为:根据实际的对象类型来判断如何调用重写函数

    (1)当父类指针(引用)指向父类对象,则调用父类中定义的成员函数;

    (2)当父类指针(引用)指向子类对象,则调用子类中定义的重写函数。

    三、多态的概念和意义

    1、多态的概念

    (1)根据实际的对象类型决定函数调用的具体目标;

    (2)同样的调用语句在实际运行时有多种不同的表现形态体现,这就是多态,同一语句具有多种形态。

    2、C++如何支持多态概念

    (1)通过使用virtual关键字对多态进行支持;

    (2)被virtual修饰的函数被重写后具有多种不同的表现形态;

    (3)被virtual声明的函数称为虚函数。

    3、多态内部运行剖析

    父类和子类的对象,首地址都各自有一个虚函数表地址,该地址都保存着虚函数Printfln()的地址,在运行过程中

    (1)在父类指针(引用)p,指向父类对象,就相当于指向父类的虚函数表,从而在父类的虚函数表中找到Printfln()函数;

    (2)在父类指针(引用)p,指向子类对象,相当于指向子类的虚函数表,从而在子类的虚函数表中找到Printfln()函数。

    4、多态的意义

    (1)在程序运行中展现出动态的特性;

    (2)函数重写必须多态实现,否则没有任何意义;

    (3)多态是面向对象组件化程序设计的基础特性。

    5、修改示例代码

    根据多态的概念,在程序中给父子类同名函数声明virtual关键字,只需要在父类中声明即可,在子类中可以不写,写了也是对的,编译器不会报错。

    #include <QCoreApplication>
    #include <iostream>
    #include <QDebug>
    
    using namespace std;
    
    class Parent
    {
    
    public:
    
        virtual void Printfln()
        {
            std::cout << "Parent: void Printfln()..." << std::endl;
        }
    };
    
    class Child : public Parent
    {
    public:
    
        void Printfln()
        {
            std::cout << "Child: void Printfln()..." << std::endl;
        }
    };
    
    void run(Parent *p)
    {
        p->Printfln();
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        Parent p;
        Child c;
    
        run(&p);
        run(&c);
    
        return a.exec();
    }
    

    四、静态联编和动态联编

    1、静态联编:程序编译期间就能确定的具体的函数调用,如函数重载;

    2、动态联编:程序运行期间才能确定的具体的函数调用,如函数重写。

    五、小结

    1、函数重写只能发生在父类和子类之间;

    2、多态是根据实际对象类型确定调用具体的函数;

    3、virtual关键字是C++支持多态的唯一方式;

    4、被重写的虚函数具有多种不同表现形态。

    展开全文
  • 多态概念的引入及案例分析

    目录

    多态的意义

    多态的问题抛出

    实现多态的解决方案

    总体代码


    多态的意义

    多态是设计模式和编写框架的一个基础,都知道的面向对象的三大概念,封装,继承和多态,其实,与其说是三大概念,不如说是三种境界,比如,封装的意义在于,突破了C语言中函数的概念,当把一个类做函数参数的时候,我们把一个类的对象传到一个被调用函数里,这样在被调用函数里面,可以直接使用这个类的属性和类的方法;再看继承,它的意义在于,继承可以复用以前人写的代码,这样就可以解决代码复用的一些难题了;最后,看多态,多态应该比继承更牛,这是因为,多态不光是继承以前人写的代码,更重要的是,多态可以复用后来人写的代码,即一个八十年代人写的代码,可以复用九十年代人写的代码,可以扩展新的标准,从这个角度看,多态应该是一个更高层次上的思想。

    多态的问题抛出

    赋值兼容性原则遇上函数重写,即如果子类定义了与父类中原型相同的函数会发生什么?

    先定义一个父类函数:

    class Parent
    {
    public:
    	Parent(int a)
    	{
    		this->a = a;
    		cout<<"Parent a"<<a<<endl;
    	}
    protected:
    private:
    	int a ;
    };

     再定义一个子类:

    class Child : public Parent
    {
    public:
    	Child(int b) : Parent(10)
    	{
    		this->b = b;
    		cout<<"Child b"<<b<<endl;
    	}
    protected:
    private:
    	int b;
    };

    这样构造关系就有了,再这个场景之下,我们再写一个print函数,再父类和子类中,分别添加print函数,在父类中添加函数:

    	void print() //子类的和父类的函数名字一样
    	{
    		cout<<"Parent 打印 a:"<<a<<endl;
    	}

    在子类中添加函数:

    	void print() //virtual 父类写了virtual,子类可写 可不写 
    	{
    		cout<<"Child 打印  b:"<<b<<endl;
    	}

     我们知道根据赋值兼容性原则,可以将子类的对象,赋给基类的指针,那么我们就直接定义一个基类的指针,

    void main()
    {
    	Parent	*base = NULL;
    	Parent	p1(20);
    	Child	c1(30);
    
    	base = &p1;
    	base->print(); //执行父类的打印函数
    
    	base = &c1;
    	base->print(); //执行谁的函数 ?  //面向对象新需求
    
    	cout<<"hello..."<<endl;
    	system("pause");
    	return ;
    }

    那么,当"base = &c1;"的时候,执行的print函数是谁的?先看看代码运行结果:

     发现,最终执行的是父类的print函数,而不是子类的。这里就存在一个新的需求,如何来调用子类的print函数,总不能每次都去调用父类的吧!

    再接着看,在主调函数中添加,新的代码段,采用引用的方式再试:

    	{
    		Parent &base2 = p1;
    		base2.print();
    
    		Parent &base3 = c1; //base3是c1 的别名
    		base3.print();
    	}

     在这种场景下,base3就是c1,那再进行打印,看看调用的是谁的print函数:

    发现调用的print函数仍旧是父类的,竟然连别名,都不别名了!

    还是不服气,再试,用指针做函数参数的方式再来调用,添加一个新的函数:

    void howToPrint(Parent *base)
    {
    	base->print(); //一种调用语句 有多种表现形态...
    }
    
    void howToPrint2(Parent &base)
    {
    	base.print();
    }

    分别对这两次函数,做一次函数调用:

    	//函数调用
    	howToPrint(&p1);
    	howToPrint(&c1);
    
    	howToPrint2(p1);
    	howToPrint2(c1);

    发现结果和之前还是一样,还是一直调用的是父类的print函数,就每调用过子类的:

     其实,我们实现的功能很简单,传来一个子类的指针对象,就执行子类的print函数,传来一个父类的指针对象,就执行父类的print函数,但经过以上尝试,发现都不行,而这就是面向对象的新需求!

    下面进行理论总结:

    编译器的做法不是我们期望的:

            根据实际的对象类型来判断重写函数的调用,如果父类指针指向的是父类对象则调用父类中定义的函数,如果父类指针指向的是子类对象则调用子类中定义的重写函数。

    我们期望的:

    对同样的调用语句有多种的不同的表现形式,像这种表现形式,我们就称之为多态!

    实现多态的解决方案

    解决方案很简单,就是加"virtual"关键字,强调的地方有两点:1)这才是"virtual"关键字,真正的主流应用场景!之前在虚继承中的应用并不是;2)如果在父类的函数中加上了"virtual"关键字,在子类中的相同函数加不加这个关键字(一般情况下都写上,表示醒目),都无所谓,都能达到实现多态的功能。

    将之前的代码进行改进,在父类的print函数前加"virtual"关键字:

    	virtual void print() //子类的和父类的函数名字一样
    	{
    		cout<<"Parent 打印 a:"<<a<<endl;
    	}

     在子类的print函数前加"virtual"关键字:

    
    	virtual void print() //virtual 父类写了virtual,子类可写 可不写 
    	{
    		cout<<"Child 打印  b:"<<b<<endl;
    	}

     这个时候,在进行调用就可以了!

    void main()
    {
    	Parent	*base = NULL;
    	Parent	p1(20);
    	Child	c1(30);
    
    	base = &p1;
    	base->print(); //执行父类的打印函数
    
    	base = &c1;
    	base->print(); //执行谁的函数 ?  //面向对象新需求
    	
    	cout<<"hello..."<<endl;
    	system("pause");
    	return ;
    }

    这样都是通过"base->print()"来调用的,就产生了不太的效果:

    这样的话,运行之前的存放在主调中的三种尝试代码,都实现了想要的功能:

     这样的就做到了一个调用语句有多种表现形态!这就是C++给我们提供的多态。

    总体代码

    dm13_类型兼容性原则遇上函数重写.cpp

    
    #include <iostream>
    using namespace std;
    
    class Parent
    {
    public:
    	Parent(int a)
    	{
    		this->a = a;
    		cout<<"Parent a"<<a<<endl;
    	}
    
    	virtual void print() //子类的和父类的函数名字一样
    	{
    		cout<<"Parent 打印 a:"<<a<<endl;
    	}
    protected:
    private:
    	int a ;
    };
    
    class Child : public Parent
    {
    public:
    	Child(int b) : Parent(10)
    	{
    		this->b = b;
    		cout<<"Child b"<<b<<endl;
    	}
    	virtual void print() //virtual 父类写了virtual,子类可写 可不写 
    	{
    		cout<<"Child 打印  b:"<<b<<endl;
    	}
    protected:
    private:
    	int b;
    };
    
    void howToPrint(Parent *base)
    {
    	base->print(); //一种调用语句 有多种表现形态...
    }
    
    void howToPrint2(Parent &base)
    {
    	base.print();
    }
    void main()
    {
    	
    	Parent	*base = NULL;
    	Parent	p1(20);
    	Child	c1(30);
    
    	base = &p1;
    	base->print(); //执行父类的打印函数
    
    	base = &c1;
    	base->print(); //执行谁的函数 ?  //面向对象新需求
    
    
    	{
    		Parent &base2 = p1;
    		base2.print();
    
    		Parent &base3 = c1; //base3是c1 的别名
    		base3.print();
    	}
    
    
    	//函数调用
    	howToPrint(&p1);
    	howToPrint(&c1);
    
    	howToPrint2(p1);
    	howToPrint2(c1);
    
    
    
    	
    	cout<<"hello..."<<endl;
    	system("pause");
    	return ;
    }

     

    展开全文
  • java继承及多态概念PPT

    2019-04-22 19:07:47
    本PPT对java继承的基本概念,语法及应用进行了讲解。在继承的基础上进一步讲解了由继承引出的方法重写及上塑造性,最后引出多态概念以及相关代码实例
  • 多态概念 Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person 类,一个Student的对象便既是Student,又是Person。 多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成...
  • java基础之继承和多态概念

    千次阅读 2016-02-19 00:01:51
    java基础之继承和多态概念 Inheritance Inheritance is a reusability mechanism in object-oriented programming. With inheritance, the common properties of various objects are exploited to form ...
  • 多态概念总结

    千次阅读 2017-03-17 17:36:02
    一、基本概念 多态:具有多种形式或形态的情形(最初来源于希腊语,在C++中有广泛的含义)。 多态分类图: 静态多态:编译器在编译期间完成的,编译器根据函数实参的类型(可能会进行隐式类型的转换),可推断出要...
  • JAVA中多态性是对象多种表现形式的体现。在面向对象中,最常见的多态发生在使用父类的引用来引用子类的对象。下面这篇文章主要给大家介绍一下,需要的朋友可以参考下
  • Java中的多态概念

    2020-03-01 01:19:13
    文章目录Java中存在多态的前提条件多态中的成员访问特点多态中向上转型和向下转型 Java中存在多态的前提条件 要有继承关系 要有方法重写 要有父类引用指向子类对象 多态中的成员访问特点 成员变量:编译看左边...
  • 一 : 多态 1.1 什么是多态 多态: 把子类对象伪装成父类类型 让父类类型指向子类对象 给子类对象起一个父类类型的名字 父类类型的引用=子类类型的对象 1.2 多态对象有那些特点 多态对象: 起了父类类型名字的子类...
  • JAVA中的多态概念

    2018-01-16 11:33:00
    多态存在的三个必要条件 需要存在继承和实现关系 同样的方法调用而执行不同操作,运行不同代码。 在运行时父类或者接口的引用变量可以引用 其子类的对象。 多态的作用  多态通过分离做什么和怎么做,从另...
  • 多态的基本概念 多态:同一种事物表现出来的多种形态。 多态语法格式 格式为:父类类型的引用指向子类类型的对象。如下所示 Person person=new Worker(); 多态的特点 (1)当父类类型的引用指向子类类型的对象时,...
  • C++封装继承多态总结 面向对象的三个基本特征 面向对象的三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用...
  • 面向对象多态概念理解

    千次阅读 2018-05-21 20:11:46
    1. 什么是多态一句话概括:父类对象引用子类变量 调用的是子类的实现例子:子类public class Chinese extends Person{ public void hello() { System.out.println("我是中国人"); } public void ...
  • C#-多态-演示 该代码代表了我在C#中对多态性概念的说明。 等级制 如类图文件Zoo.cd所示 Animal.cs(基类) | | | | ---- Lion.cs(儿童班) | | ---- Monkey.cs(儿童班) | | ---- Zebra.cs(子类)
  •  概念:可以理解为时一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来定义  class:用于定义类  interface 用于定义接口  语法:访问权限修饰符 interface 接口名{  //全局...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,091
精华内容 5,636
关键字:

多态概念