多态(polymorphism)，覆盖(Override)，重载(overload)

关注

原创最新推荐文章于 2026-03-12 00:47:53 发布 1w 阅读 AI 写同款· GEO 优化 ›

多态&重载、隐藏（重定义）、重写（覆盖）多态：多态按字面的意思就是多种形态，相同的方法调用，但是有不同的实现方式。多态性可以简单地概括为“一个接口，多种方法”。C++有两种多态形式：静态多态动态多态静态多态（静态绑定）：也称为编译期间的多态，编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。静态多态有两种实现方式：函数重载：包括普通函数的重载和成员函数的重载函数模板的使用动态多态（动态绑定）：即运行时的多态，在程序执阅读详情

多态(polymorphism)
覆盖(Override)
重载(overload)
也有把override译为重载的。
关于override和overload的翻译，好像不是很统一。
更多的应该是：
覆盖（override）和重载（overload）

1。

覆盖 override：

Overriding 也许叫做overwriting更合适，
OVERLOAD覆盖是指在子类（c++中的派生类）中重新定义父类的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和被覆盖函数只有函数体（花括号中的部分）不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本。
比如

代码:

#ruby code
class Base
def m1
puts "in base"
end
end

class Sub < Base
def m1
puts "in sub"
end

end

我们说Sub类覆盖了父类的m1方法

2。
重载（overload）：
在同一个类中，出现多个同名的方法的现象就是Overload
重载事发生在同一个类中，不同方法之间的现象。

在c++或者java中，方法一般为
返回类型方法名(参数1，参数2)
判断2个方法是不是overload，主要指方法名一样，参数不一样，
参数不一样指的是参数的个数，相同位置的参数的类型是否一样，而与参数（型参）的名称无关（参数类型/个数/顺序,不同），
与返回类型也无关。程序会根据不同的参数列来确定需要调用的函数
比如c++或者java中，这都是overload
void m1();
void m1(int arg);
void m1(int arg, char* x);

在ruby中，不存在这样的overload

代码:

#ruby code
def method_a(a)
puts "method_a(a) "+a.to_s
end

def method_a(a,b)
puts "method_a(a,b) "+a.to_s+" "+b.to_s
end

method_a("a") #这句会出错，因为这个方法的定义已经被method_a(a,b)重定义给覆盖了

method_a("a","b")

method_a("a") 这句会出错，因为这个方法的定义已经被method_a(a,b)重定义给覆盖了
因为ruby的弱类型和可变参数列表，使得overload不是很明显。

3。
多态(polymorphism)
至于多态，我还没有见过一个看一眼就能明白的定义。
有的说是允许将子类类型的指针赋值给父类类型的指针，当然java中没有指针的概念。
多态有时候也被称为动态绑定或者晚绑定或运行时绑定，意思是编译的时候不必关心，运行的时候才决定调用哪个对象的哪个方法。
我觉得多态的用途之一就是在父类提供一个接口（服务），然后调用的时候用的却是子类的具体实现。这个结合java中的interface应该是比较形象的，但是我懒得再去写几个例子了。
先来看一个java中不用interface的例子：

代码:

//java code
public class Base{

void m1(){
System.out.println("in base,m1");
}

void m2(){
System.out.println("in base,m2");
}

public static void main(String[] argv){
Base b=new Sub();
b.m1();
b.m2();

}
}

class Sub extends Base {
void m1(){
System.out.println("in sub,m1");
}

}

在main方法中b声明为Base类型，而实例化的时候是一个Sub类的实例，Sub中没有实现m2方法，所以，将调用Base的m2方法，而Sub overwirte了父类的m1方法，所以，b.m2()将调用Sub类的m1方法。

在c++中可能负杂点：

代码:

//c++ code
#include <iostream.h>

class Base{
public:
void m1(){
cout<<"i am in base /n";
}
virtual void m2(){
cout<<"i am in base ,virtual /n";
}
};

class Sub:public Base{
public:
void m1(){
cout<<"i am in sub /n";
}
virtual void m2(){
cout<<"i am in sub ,virtual /n";
}
};

void fnm1(Base& b ){
b.m1();
}
void fnm2(Base& b ){
b.m2();
}

int main(void)
{

Sub s;
s.m1();
s.m2();
Base b;
b.m1();
b.m2();
Base* bs=new Sub();
bs->m1();
bs->m2();
delete bs;

Sub s;
fnm1(s);
fnm2(s);
return(0);
}