多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数（Virtual
Function） 实现的。
多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOD）的一个重要特征。如果一个语言只支持类而不支多态，只能说明它是基于对象的，而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。
　　C++中，实现多态有以下方法：虚函数，抽象类，重载，覆盖
java多态的实现主要体现在哪些方面
多态可分为： 1.编译多态：主要是体现在重载，系统在编译时就能确定调用重载函数的哪个版本。 2.运行多态：主要体现在OO设计的继承性上，子类的对象也是父类的对象，即上溯造型，所以子类对象可以作为父类对象使用，父类的对象变量可以指向子类对象。因此通过一个父类发出的方法调用可能执行的是方法在父类中的实现，也可能是某个子类中的实现，它是由运行时刻具体的对象类型决定的。
方法的重写和重载是多态性的不同表现。重写是父类与子类之间多态性的一种表现，重载是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。的方法是可以改变返回值的类型。
在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。
在派生类对象上直接调用这个函数名，只会调用派生类中的那个。
//coverage.cpp
#include &iostream&
& void ShowMessage();
class B:public A
& void ShowMessage();
void A::ShowMessage()
& cout&&&Hello,This is A./n&;
void B::ShowMessage()
& cout&&&Hello,This is B./n&;
int main()
& p-&ShowMessage();
& memb.ShowMessage();
& return 0;
Hello,This is A.
Hello,This is B.
有两个或多个函数名相同的函数，但是函数的形参列表不同。在调用相同函数名的函数时，根据形参列表确定到底该调用哪一个函数。
#include &iostream&
& void ShowMessage();
& void ShowMessage(string str);
void A::ShowMessage()
cout&&&Hi,This is A./n&;
void A::ShowMessage(string str)
& cout&&str&&
int main()
& mem.ShowMessage();
& mem.ShowMessage(&Hello.How are you?/n&);
& return 0;
Hi,This is A.
Hello.How are you?
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声雷中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。
//poly.cpp
#include &iostream&
&& virtual void ShowMessage();
class B:public A
& void ShowMessage();
void A::ShowMessage()
& cout&&&This is A./n&;
void B::ShowMessage()
& cout&&&This is B./n&;
int main()
& p=new A();
& p-&ShowMessage();
& p=new B();
& p-&ShowMessage();
& return 0;
This is A.
This is B.
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：108次
排名：千里之外
转载：22篇1035人阅读
【C++拾遗】（9）
#include &iostream&
class Base
protected:
void printProtected()
cout&&&Print Protected&&&
void printPublic()
cout&&&Print Public&&&
class Derived1 : protected Base
class Derived2 : private Base
class A : public Derived1
void Print()
printProtected();
printPublic();
class B : public Derived2
void Print()
//因为Derived2是private继承自Base，所以Derived2继承自Base的成员不能被继承到class B
//所以下面两行代码会出现调用错误
printProtected();
printPublic();
int main()
a.Print();
b.Print();
4、私有继承
#include &iostream&
class Person
void eat()
cout&& &Person eat& &&
class Student : private Person
void study()
cout&& &Student study& &&
int main()
s.study();
s.eat(); //erro
#include &iostream&
class Person
virtual void print()
cout && &I'm a Person& &&
class Chinese : public Person
virtual void print()
cout&& &I'm from China& &&
class American : public Person
virtual void print()
cout&&&I'm from USA&&&
void printPerson(Person &person)
person.print();
int main()
printPerson(p);
printPerson(c);
printPerson(a);
class Parent
virtual void foo1(){}
void foo2(){}
class Child1 : Parent
virtual void foo1(){}
void foo3(){}
class Child2 : Child1
void foo1(){}
void foo2(){}
void foo3();
下面来几个例子：
#include &stdio.h&
virtual doSth()
printf(&I am A&);
virtual doSth2()
printf(&In A&);
class B : public A
virtual void doSth()
printf(&I am B&);
virtual doSth2()
printf(&In B&);
int main()
//在构造函数中，虚拟机制不会发生作用，因为基类的构造函数在
//派生类构造函数之前执行，当基类构造函数运行时，派生类数据
//成员还没有被初始化。如果基类构造期间调用的虚函数向下匹配
//到派生类，派生类的函数理所当然会实际本地数据成员，但是数
//据成员还没有初始化，而调用涉及对象还没有被初始化的部分自
//然是危险的，所以C++会提示编译错误。因此虚函数不会向下匹配
//到派生类，而是直接执行基类的函数。
//在构造完成后就会向下匹配
A *p = &b;
p-&doSth(); //I am B
再来一个例子
#include &iostream&
virtual void print()
cout&& &A::print()& &&
class B : public A
virtual void print()
cout &&B::print()& &&
class C : public A
void print(void)
cout&&&C::print()&&&
void print(A a)
//存在对象的类型转换，对象拷贝
a.print();
void print(A* a)
a-&print();
int main()
A a,*pa,*pb,*
a.print();
b.print();
c.print();
pa-&print();
pb-&print();
pc-&print();
print(&a);
print(&b);
print(&c);
#include &iostream&
#include &string&
void println(const std::string &msg)
cout&& msg &&
class Base
println(&Base::Base()&);
println(&Base::f()&);
virtual void virt()
println(&Base::virt()&);
class Derived : public Base
println(&Derived::Derived()&);
virtual void virt()
println(&Derived::virt()&);
int main()
Base *pB = &d;
三、纯虚函数和抽象基类
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：92478次
积分：1907
积分：1907
排名：第15144名
原创：93篇
转载：10篇
评论：16条
欢迎关注，交流
文章：13篇
阅读：15814
(2)(10)(15)(7)(12)(3)(9)(3)(7)(4)(17)(1)(2)(6)(4)C++的虚函数和JAVA的抽象函数
C++中具备两种虚拟函数：虚函数和纯虚函数。跟JAVA相比，虚函数相当于JAVA中的普通函数，而纯虚函数则为JAVA中的抽象函数。
&&&&C++的虚函数是在函数前加上virtual修饰符，主要用于多态（见最后的解释）。函数具有函数体，只是为了表明该函数调用是动态的，根据实例化对象而来（C++）。而JAVA中默认就是这种方式。
纯虚函数和抽象函数都没有函数体，纯虚函数是在虚函数声明上后面加上“=0”，如“virtual void
showmember()=0;&”，声明了纯虚函数的，此类不用使用任何修饰符即成为了抽象类。
在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。在派生类对象上直接调用这个函数名，只会调用派生类中的那个。
在基类中定义了一个非虚拟函数，然后在派生类中定义一个同名，但是具有不同的参数表的函数，这就是重载。在派生类对象上调用这几个函数时，用不同的参数会调用到不同的函数，有可能会直接调用到基类中的那个。
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声雷中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。覆盖&重载&多态
1. C++里子类会覆盖基类里的同名同参函数吗？
不用指针调用函数的话,会覆盖,类似虚函数一样.
如果是有意的覆盖,最好把基类的函数定义为虚函数.
当用指针调用时候就不会覆盖.
因为定义一个基类指针,当通过这个指针调用所指向子类对象函数时候,就会调用基类的函数,而不是子类的
你可以编个简单的程序测试下就知道了,定义个基类B和 子类C,在c里重写b的函数fun();
然后main里定义个指针调用测试下
int main()
在基类中定义了一个非虚拟函数，然后在派生类中又定义了一个同名同参数同返回类型的函数，这就是覆盖了。在派生类对象上直接调用这个函数名，只会调用派生类中的那个。
在基类中定义了一个非虚拟函数，然后在派生类中定义一个同名，但是具有不同的参数表的函数，这就是重载。在派生类对象上调用这几个函数时，用不同的参数会调用到不同的函数，有可能会直接调用到基类中的那个。
在基类中定义了一个虚拟函数，然后在派生类中又定义一个同名，同参数表的函数，这就是多态。多态是这3种情况中唯一采用动态绑定技术的一种情况。也就是说，通过一个基类指针来操作对象，如果对象是基类对象，就会调用基类中的那个函数，如果对象实际是派生类对象，就会调用派声雷中的那个函数，调用哪个函数并不由函数的参数表决定，而是由函数的实际类型决定。
重载、覆盖、隐藏
在csdn上经常看到这种问题 ，如何区别3者，从论坛中已经能够找到完善的答案，现在自己也总结一下，加深印象，同时希望对读者您有用。
这不是一个新的概念，在c++中一个比较重要的概念(c语言里面不允许)，特征就是允许函数名相同，通过指定不同的参数或者返回值来区别。
这里我们所说的重载是针对c++中类的，类中重载与前面所说的也完全一样。
特点： 1.在同一个类内
2.相同的函数名
3.不同参数
覆盖是c++面向对象提出的一个新概念，如果实现覆盖呢？ 这个也就是我们常说的多态。通过一个虚函数表实现的，基类使用virtual来声明一个函数为虚函数，建立了一张虚函数表，如果子类重写该函数，子类实例的指针就会指向重写的函数。这就造成了，相关实例(子类，基类)对同一接口调用时产生不同效果，我们称之为多态。多态是c++的高级特性。
特点：1.在不同类内(一个在子类，一个在父类)
2.基类函数需要使用virtual声明,子类的可有可无
3.函数名，参数均需相同
隐藏是一种现象，也算是一种特性，在c++中，子类可以让调用者看不到父类同名函数，也就是说子类中不能使用父类的同名函数，这种现象叫隐藏。
特点：1.在不同类内(一个在子类，一个在父类)
2.函数名相同
2.如果基类函数使用了virtual，那么子类函数需要有不同的参数
4.如果基类没有virtual，那么子类函数可以与基类的函数完全相同，也可不同
网友PC总结：
1. 重载：看参数(参数)
2. 隐藏：用什么就调用什么(子类看不到基类的隐藏函数)
3. 覆盖：调用派生类 (传什么指针调谁的)
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。