override->重写(=覆盖)、overload->重载、polymorphism -> 多态
override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。
重写（覆盖）的规则：
1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.
2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。
3、重写的方法的返回值必须和被重写的方法的返回一致；
4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类；
5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
6、静态方法不能被重写为非静态的方法（会编译出错）。
overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。
重载的规则：
1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
多态的概念比较复杂，有多种意义的多态，一个有趣但不严谨的说法是：继承是子类使用父类的方法，而多态则是父类使用子类的方法。
一般，我们使用多态是为了避免在父类里大量重载引起代码臃肿且难于维护。
举个例子：
public class Shape
{
public static void main(String[] args){
Triangle tri = new Triangle();
System.out.println("Triangle is a type of shape? " + tri.isShape());// 继承
Shape shape = new Triangle();
System.out.println("My shape has " + shape.getSides() + " sides."); // 多态
Rectangle Rec = new Rectangle();
Shape shape2 = Rec;
System.out.println("My shape has " + shape2.getSides(Rec) + " sides."); //重载
}
public boolean isShape(){
return true;
}
public int getSides(){
return 0 ;
}
public int getSides(Triangle tri){ //重载
return 3 ;
}
public int getSides(Rectangle rec){ //重载
return 4 ;
}
}
class Triangle extends Shape
{
public int getSides() { //重写,实现多态
return 3;
}
}
class Rectangle extends Shape
{
public int getSides(int i) { //重载
return i;
}
}
注意Triangle类的方法是重写，而Rectangle类的方法是重载。对两者比较，可以发现多态对重载的优点：
如果用重载，则在父类里要对应每一个子类都重载一个取得边数的方法；
如果用多态，则父类只提供取得边数的接口，至于取得哪个形状的边数，怎样取得，在子类里各自实现(重写)。
---------------------
作者：Erik明
来源：CSDN
原文：https://blog.csdn.net/ericbaner/article/details/3857268
版权声明：本文为博主原创文章，转载请附上博文链接！
https://blog.csdn.net/qq_34634812/article/details/81369270
重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！
综述：
一、重载：
（1）概念
在同一个作用域内，函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同，这种情况叫做c++的重载！
注意：c语言没有函数重载的机制；
详见：http://blog.csdn.net/gogogo_sky/article/details/72807123
（2）举例：
#include<iostream>
using namespace std;
int Add(int a,int b)
{
return a+b;
}
float Add(float a,float b)
{
return a+b;
}
int main()
{
cout<<Add(4,5)<<endl;//调用 int Add(int a,int b)
cout<<Add(2.5f,3.7f)<<endl;//调用 float Add(float a,float b)
return 0;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
此时，两个函数Add();在同一作用域，函数名相同都是Add，参数类型不同；就构成了c++中的函数重载；
（3）c++函数重载达到的效果：调用函数名相同的函数，会根据实参的类型和实参顺序以及实参个数选择相应的函数；
（4）c++函数重载是一种静态多态（又叫做静态联编，静态绑定，静态决议）
二、覆盖（又叫重写）
（1）说覆盖之前先说一个概念：
虚函数：类的成员函数前面加virtual关键字，则这个成员函数称为虚函数
（2）覆盖（重写）的前提条件：父类函数为虚函数；
（3）覆盖（重写）的概念：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。
（4）什么是在子类中定义了一个与父类完全相同的虚函数：
有两种情况：
-
1)、就是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型，返回值类型都相同；这种情况下子类的这个虚函数重写的父类中的虚函数，构成了重写；
-
2)、协变—是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型都相同，只是返回值类型不同；父类的虚函数返回父类的指针或者引用，子类虚函数返回子类的指针或者引用；这种情况下子类的这个虚函数也重写了父类中的虚函数，也构成了重写；——我们把这种特殊的情况叫做协变
注意：
在子类中定义了一个与父类虚函数完全相同的函数，那么这个子类的函数就是重写了父类的虚函数，此时这个子类的函数就是虚函数，如果不显示的加上virtual修饰，编译器也会默认为虚函数；
（5）覆盖（重写）达到的效果：
-
1.在子类中重写了父类的虚函数，那么子类对象调用该重写函数，调用到的是子类内部重写的虚函数，而并不是从父类继承下来的虚函数；（这其实就是动态多态的实现）；
-
2.在子类中重写了父类的虚函数，如果用一个父类的指针（或引用）指向（或引用）子类对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是子类的虚函数；相反，如果用一个父类的指针（或引用）指向（或引用）父类的对象，那么这个父类的指针或用引用调用该重写的虚函数，调用的是父类的虚函数
（6）举例1：普通重写+函数重载
//普通重写+函数重载
#include<iostream>
using namespace std;
class Person//父类
{
public:
virtual void BuyTickets()//父类虚函数
{
cout<<" 买票-全票"<< endl;
}
protected :
string _name; // 姓名
};
class Student : public Person//子类
{
public:
void BuyTickets()//子类虚函数
{
cout<<" 买票-半价"<<endl ;
}
protected :
int _num ; //学号
};
void Fun (Person* p)
{
p->BuyTickets();
}
void Fun (Person&p)
{
p.BuyTickets();
}
void Test ()
{
Person p ;
Student s;
Fun(p);
Fun(s);
Fun(&p);
Fun(&s);
}
int main()
{
Test();
return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
分析：
在子类中的函数 void BuyTickets()和父类的虚函数virtual void BuyTickets()，他们的函数名相同都为BuyTickets，参数相同都为空，返回值都相同为void，所以此时子类中的函数void BuyTickets()重写了父类的虚函数virtual void BuyTickets()；那么这是即使子类的函数void BuyTickets()不加关键字virtual修饰，编译器默认它为虚函数；
父类的指针Person* p（或引用Person&p）指向（或引用）子类对象s，那么这个父类的指针或用引用调用该重写的虚函数，调用的是子类的虚函数；
相反，用一个父类的指针Person* p（或引用Person&p）指向（或引用）父类的对象p，那么这个父类的指针或用引用调用该重写的虚函数，调用的是父类的虚函数
其中：
void Fun (Person* p)
{
p->BuyTickets();
}
void Fun (Person&p)
{
p.BuyTickets();
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
这两个哈数构成了函数重载
举例二：协变重写+函数重载
//（协变）重写+函数重载
#include<iostream>
using namespace std;
class Person//父类
{
public:
virtual Person& BuyTickets()//父类虚函数
{
cout<<"成人买票-全票"<<endl;
return *this;
}
public:
string _name; // 姓名
};
class Student : public Person//子类
{
public:
virtual Student& BuyTickets()//子类虚函数
{
cout<<"学生买票-半票"<<endl;
return *this;
}
public:
int _num ; //学号
};
void Fun (Person* p)
{
p->BuyTickets();
}
void Fun (Person&p)
{
p.BuyTickets();
}
void Test ()
{
Person p;
Student s;
Fun(p);
Fun(s);
Fun(&p);
Fun(&s);
}
int main()
{
Test();
return 0;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
三、隐藏（重定义）
（1）隐藏（重定义）概念：
是指在不同的作用域中（分别在父类和子类中），函数名相同，不能构成重写的都是重定义。
（2）隐藏（重定义）的使用范围：
重定义的不光是类的成员函数，还可以是类的成员变量；
（3）隐藏（重定义）的直接效果：
如果在父类和子类中有相同名字的成员；那么在子类中。会将父类的成员隐藏；隐藏以后的直接效果就是：无论在子类的内部或者外部（通过子类成员）访问该成员；全都是访问子类的同名成员； 如果在子类内部或者外部（通过子类成员）访问同名的成员函数，则需要根据函数调用的规则来调用子类的同名成员函数；否则调用失败；
#include<iostream>
using namespace std;
class A
{
protected:
A(int x=2)
:_a(x)
{}
//public:
// //1
// void show()
// {
// cout<<"A::shou()"<<endl;
// }
//public:
// //2
// virtual void show()
// {
// cout<<"A::shou()"<<endl;
// }
public:
//3
void show(int a)
{
cout<<"A::shou()"<<endl;
}
public:
int _a;
};
class B:public A
{
public:
B(int x=1)
:_a(x)
{}
//public:
// //1
// void show(int b)
// {
// cout<<"B::shou()"<<endl;
// }
//public:
// //2
// void show(int a)
// {
// cout<<"B::shou()"<<endl;
// }
public:
//3
void show(int a,int b)
{
cout<<"B::shou()"<<endl;
cout<<_a<<endl;
}
public:
int _a;
};
int main()
{
B b;
cout<<(b._a)<<endl;
b.show(1);
return 0;
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
程序中所标明的1，2，3三种情况都是成员隐藏！
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
