参考博客:点击打开链接
重载与覆盖的区别
1、方法的覆盖是子类和父类之间的关系,是垂直关系;方法的重载是同一个类中方法之间的关系,是水平关系。
2、覆盖只能由一个方法,或只能由一对方法产生关系;方法的重载是多个方法之间的关系。
3、覆盖要求参数列表相同;重载要求参数列表不同。
4、覆盖关系中,调用那个方法体,是根据对象的类型(对象对应存储空间类型)来决定;重载关系,是根据调用时的实参表与形参表来选择方法体的。
override可以翻译为覆盖,从字面就可以知道,它是覆盖了一个方法并且对其重写,以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现,在接口中一般只是对方法进行了声明,而我们在实现时,就需要实现接口声明的所有方法。除了这个典型的用法以外,我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点:
面向对象程序设计中的另外一个重要概念是多态性。在运行时,可以通过指向基类的指针,来调用实现派生类中的方法。可以把一组对象放到一个数组中,然后调用它们的方法,在这种场合下,多态性作
用就体现出来了,这些对象不必是相同类型的对象。当然,如果它们都继承自某个类,你可以把这些派生类,都放到一个数组中。如果这些对象都有同名方法,就可以调用每个对象的同名方法。
同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。多态性通过派生类重载基类中的虚函数型方法来实现。
在面向对象的系统中,多态性是一个非常重要的概念,它允许客户对一个对象进行操作,由对象来完成一系列的动作,具体实现哪个动作、如何实现由系统负责解释。
“多态性”一词最早用于生物学,指同一种族的生物体具有相同的特性。在C#中,多态性的定义是:同一操作作用于不同的类的实例,不同的类将进行不同的解释,最后产生不同的执行结果。C#支持两种类型的多态性:
● 编译时的多态性
编译时的多态性是通过重载来实现的。对于非虚的成员来说,系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。
● 运行时的多态性
运行时的多态性就是指直到系统运行时,才根据实际情况决定实现何种操作。C#中,运行时的多态性通过虚成员实现。
编译时的多态性为我们提供了运行速度快的特点,而运行时的多态性则带来了高度灵活和抽象的特点。
1、类成员函数的重载、重写、和覆盖区别
a.成员函数被重载的特征:
(1)相同的范围(在同一个类中);
(2)函数名字相同;
(3)参数不同(重载函数的主要特征);
(4)virtual关键字可有可无;
(5)不受返回值影响。
b.覆盖是指派生类函数覆盖基类函数,特征是:
(1)不同的范围(分别位于派生类与基类);
(2)函数名字相同;
(3)参数相同;
(4)基类函数必须有virtual关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
(1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)
2、"隐藏"实例分析
- #include "stdafx.h"
- #include <iostream.h>
- #include <string.h>
- class A
- {
- public:
- void hello(){cout<<"A hello"<<endl;}
- virtual void hello(int i){cout<<"A hello int"<<endl;}
- };
- class B:public A
- {
- public:
- void hello() const{cout<<"B hello"<<endl;} //B中的hello()隐藏了A中的hello(int)
- };
- //重载时的隐藏问题,解决办法,在B中重新定义hello(int)函数
- void main()
- {
- B b;
- b.hello();
- // b.hello(1); //error
- }
3、虚函数实例分析1
- #include "stdafx.h"
- #include <iostream.h>
- #include <string.h>
- class A
- {
- protected:
- int i;
- public:
- A(int d=0){i=d;}
- int GetData(){return doGetData();}
- virtual int doGetData(){return i;} //虚函数
- };
- class B:public A
- {
- protected:
- int i;
- public:
- B(int d=1){i=d;}
- int doGetData(){return i;}
- };
- class C:public B
- {
- protected:
- int i;
- public:
- C(int d=2){i=d;}
- };
- void main()
- {
- C c(10);
- /* B和的C对象调用一般成员函数GetData()都是调用的A类中的GetData(),因为A中的doGetData()是虚函数,所以调用B类中的doGetData() */
- /* B和的C对象调用虚函数doGetData()都是调用的B类中的重定义的doGetData(),除非显示指定调用哪个类的虚函数 */
- cout<<c.GetData()<<" "; /* 本来要调用C的GetData(),C中未定义,故调用B中的,但是B中也未定义,故调用A的GetData(),因为A中的doGetData()是虚函数,所以调用B中的doGetData(),返回B::i */
- cout<<c.A::GetData()<<" ";
- cout<<c.B::GetData()<<" ";
- cout<<c.C::GetData()<<" ";
- cout<<c.doGetData()<<" "; /* 调用B类中的doGetData() */
- cout<<c.A::doGetData()<<" "; /* 直接调用A类中的doGetData() */
- cout<<c.B::doGetData()<<" "; /* 直接调用B类中的doGetData() */
- cout<<c.C::doGetData()<<endl; /* 因为C没有重定义doGetData(),所有调用B中的doGetData()*/
- //答案:1 1 1 1 1 0 1 1
- }
4、虚函数实例分析2
- #include "stdafx.h"
- #include <iostream.h>
- #include <string.h>
- class A
- {
- public:
- virtual void display(){cout<<"A"<<endl;} //虚函数
- };
- class B:public A
- {
- public:
- virtual void display(){cout<<"B"<<endl;} //虚函数
- };
- void main()
- {
- A *pa=new A;
- pa->display(); //调用A中的虚函数
- B *pb=(B*)pa; //pb指向pa,而pa始终指向A的对象,故调用A中的虚函数
- pb->display();
- delete pa,pb;
- pa=new B;
- pa->display(); //调用B中的虚函数
- pb=(B*)pa; //pb指向pa,pa始终指向B的对象,故调用B中的虚函数
- pb->display();
- }
5、虚继承分析
- #include "stdafx.h"
- #include <iostream.h>
- #include <string.h>
- class A
- {
- char a[3];
- public:
- virtual void display1(){} //虚函数
- };
- class B:public virtual A //虚继承
- {
- char b[3];
- public:
- virtual void display2(){} //虚函数
- };
- class C:public virtual B //虚继承
- {
- char c[3];
- public:
- virtual void display3(){} //虚函数
- };
- void main()
- {
- cout<<sizeof(A)<<" "; //8 char a[3]、虚指针
- cout<<sizeof(B)<<" "; //20 char b[3]、虚指针、虚继承的指针、父类
- cout<<sizeof(C)<<endl; //32 char c[3]、虚指针、虚继承的指针、父类
- }