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

多态(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); }

在c++中，需要virtual关键字（当然Sub::m2()的virtual是可以省略的）
运行结果如下：

代码:

i am in sub i am in sub ,virtual i am in base i am in base ,virtual i am in base i am in sub ,virtual i am in base i am in sub ,virtual

fnm2(Base& b )中，b是一个Sub类型，如果这个方法是virtual的，则调用Sub的m2，否则，调用Base的m2。
而Ruby的弱类型性，也不怎么存在这个问题。

代码:

#ruby code class Base def m1 puts "in base" end end   class Sub < Base def m1 puts "in sub" end   end   def fn(a) a.m1 end   a=Sub.new fn(a) b=Base.new fn(b)

 

总之，多态性是面向对象的基本特性，而overload应该不算是面向对象的特性吧。