重写、覆盖、重载和多态的区别

override->重写(=覆盖)、overload->重载、polymorphism -> 多态 

override是重写（覆盖）了一个方法，以实现不同的功能。一般是用于子类在继承父类时，重写（重新实现）父类中的方法。 
重写（覆盖）的规则： 
   1、重写方法的参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载. 
   2、重写方法的访问修饰符一定要大于被重写方法的访问修饰符（public>protected>default>private）。 
   3、重写的方法的返回值必须和被重写的方法的返回一致； 
   4、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类； 
   5、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。 
   6、静态方法不能被重写为非静态的方法（会编译出错）。 

overload是重载，一般是用于在一个类内实现若干重载的方法，这些方法的名称相同而参数形式不同。 
重载的规则： 
   1、在使用重载时只能通过相同的方法名、不同的参数形式实现。不同的参数类型可以是不同的参数类型，不同的参数个数，不同的参数顺序（参数类型必须不一样）； 
   2、不能通过访问权限、返回类型、抛出的异常进行重载； 
   3、方法的异常类型和数目不会对重载造成影响；

 

多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。

例子：

class A
{
public:
    A(){}
    virtual void foo()
    {
        cout<<"This is A."<<endl;
    }
};
 
class B: public A
{
public:
    B(){}
    void foo()
    {
        cout<<"This is B."<<endl;
    }
};
 
int main(int argc, char *argv[])
{
    A *a = new B();
    a->foo();
    if(a != NULL)
    delete a;
    return 0;
}

以上代码将显示：This is B.

如果把virtual去掉，将显示：

This is A.

前面的多态通过使用虚函数virtual void foo()来实现。

 

在java中：

多态，是面向对象的程序设计语言最核心的特征。多态，意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。从程序设计的角度而言，多态可以这样来实现（以java语言为例）：

public interface Parent//父类接口
{
    public void simpleCall();
}
public class Child_A implements Parent
{
    public void simpleCall();
    {
    //具体的实现细节；
    }
}
 
public class Child_B implements Parent
{
    public void simpleCall();
    {
    //具体的实现细节；
    }
}

//当然还可以有其他的实现

然后，我们就可以看到多态所展示的特性了：

Parent pa = new Child_A();

pa.simpleCall()则显然是调用Child_A的方法；

Parent pa = new Child_B();

pa.simpleCall()则是在调用Child_B的方法。所以，我们对于抽象的父类或者接口给出了我们的具体实现后，pa 可以完全不用管实现的细节，只访问我们定义的方法，就可以了。

这个考试考了，我当时没理解。

 

使用继承性的结果就是当创建了一个类的家族，在认识这个类的家族时，就是把子类的对象当作基类的对象，这种认识又叫作upcasting（向上转型）。这样认识的重要性在于：我们可以只针对基类写出一段程序，但它可以适应于这个类的家族，因为编译器会自动找出合适的对象来执行操作。这种现象又称为多态性。而实现多态性的手段又叫称动态绑定(dynamic binding)。

 

 

我之前一直对重载和多态有自己的误解，而且在给新生面试的时候还出了点岔子233333，所以在此把它们的区别写一下。

然后，就是在编译的过程中，有以下区别：

不难看出，两者的区别在于编译器何时去寻找所要调用的具体方法。

对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，编译器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。 

以上。

参考博客：http://blog.csdn.net/weigb/article/details/1864192

http://blog.csdn.net/baggio7095586/article/details/6149261

https://baike.baidu.com/item/%E5%A4%9A%E6%80%81/2282489?fr=aladdin