Java中的方法重载(method overloading)和方法重写(method Overriding)的区别

方法重载：

方法重载是Java实现多态性的一种方式。当一个重载方法被调用时，Java用参数的类型和（或）数量来表明实际调用的重载方
法的版本。因此，每个重载方法的参数的类型和（或）数量必须是不同的。虽然每个重载方法可以有不同的返回类型，但返回类型并不足以区分所使用的是哪个方法。当Java调用一个重载方法时，参数与调用参数匹配的方法被执行。无法也不能以返回型别作为重载函数的区分标准

比如：

class OverloadDemo { 
void test() { 
System.out.println("No parameters"); 
} 
// Overload test for one integer parameter. 
void test(int a) { 
System.out.println("a: " + a); 
} 
// Overload test for two integer parameters. 
void test(int a，int b) { 
System.out.println("a and b: " + a + " " + b); 
} 
// overload test for a double parameter 
double test(double a) { 
System.out.println("double a: " + a); 
return a*a; 
} 
} 

方法重写：

类层次结构中，如果子类中的一个方法与它超类中的方法有相同的方法名和类型声明，
称子类中的方法重写（override）超类中的方法。从子类中调用重写方法时，它总是引用子
类定义的方法。而超类中定义的方法将被隐藏和覆盖，从而达到重写的效果。

  

/ Method overriding. 
class A { 
int i, j; 
A(int a, int b) { 
i = a; 
j = b; 
} 
// display i and j 
void show() { 
System.out.println("i and j: " + i + " " + j); 
} 
} 
class B extends A { 
int k; 
B(int a, int b, int c) { 
super(a, b); 
k = c; 
} 
// display k – this overrides show() in A 
void show() { 
System.out.println("k: " + k); 
} 
} 
class Override { 
public static void main(String args[]) { 
B subOb = new B(1, 2, 3); 
subOb.show(); // this calls show() in B 
} 
} 

程序输出如下：
k: 3 

当一个B类的对象调用show( )时，调用的是在B中定义的show( )版本。也就是说，B中
的show( )方法重载了A中声明的show( )方法。
如果你希望访问被重载的超类的方法，可以用super。

方法重写构成Java的一个最强大的概念的基础：动态方法调度（dynamic method 
dispatch）。动态方法调度是一种在运行时而不是编译时调用重写方法的机制。动态方法调

度是很重要的，因为这也是Java实现运行时多态性的基础。 

重述一个重要的原则开始：超类的引用变量可以引用子类对象。Java用这一事实来解决在运行期间对重载方法的调用。

下面是阐述动态方法调度的例子：
 

// Dynamic Method Dispatch 
class A { 
void callme() { 
System.out.println("Inside A's callme method"); 
} 
} 
class B extends A { 
// override callme() 
void callme() { 
System.out.println("Inside B's callme method"); 
} 
} 
class C extends A { 
// override callme() 
void callme() { 
System.out.println("Inside C's callme method"); 
} 
} 
class Dispatch { 
public static void main(String args[]) { 
A a = new A(); // object of type A 
B b = new B(); // object of type B 
C c = new C(); // object of type C 
A r; // obtain a reference of type A 
r = a; // r refers to an A object 
r.callme(); // calls A's version of callme 
r = b; // r refers to a B object 
r.callme(); // calls B's version of callme 
r = c; // r refers to a C object 
r.callme(); // calls C's version of callme 
} 
} 

该程序的输出如下：
Inside A’s callme method 
Inside B’s callme method 
Inside C’s callme method

重写方法是Java实现它的多态性   ——     “一个接口，多个方法”的另一种方式。