最近看了一下關於java的基礎知識，對此作了一下蒐集整理: 

java中的繼承，方法覆蓋（重寫）override與方法的過載overload的區別 

方法的重寫(Overriding)和過載(Overloading)是Java多型性的不同表現。   
重寫(Overriding)是父類與子類之間多型性的一種表現，而過載(Overloading)是一個類中多型性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和引數，我們說該方法被重寫 (Overriding) 。子類的物件使用這個方法時，將呼叫子類中的定義，對它而言，父類中的定義如同被"遮蔽"了。如果在一個類中定義了多個同名的方法，它們或有不同的引數個數或有不同的引數型別或有不同的引數次序，則稱為方法的過載(Overloading)。不能通過訪問許可權、返回型別、丟擲的異常進行過載。 

1. Override 特點   
1、覆蓋的方法的標誌必須要和被覆蓋的方法的標誌完全匹配，才能達到覆蓋的效果；   
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；   
3、覆蓋的方法所丟擲的異常必須和被覆蓋方法的所丟擲的異常一致，或者是其子類； 
4、方法被定義為final不能被重寫。  
5、對於繼承來說，如果某一方法在父類中是訪問許可權是private，那麼就不能在子類對其進行重寫覆蓋，如果定義的話，也只是定義了一個新方法，而不會達到重寫覆蓋的效果。（通常存在於父類和子類之間。） 

2.Overload 特點   
1、在使用過載時只能通過不同的引數樣式。例如，不同的引數型別，不同的引數個數，不同的引數順序（當然，同一方法內的幾個引數型別必須不一樣，例如可以是fun(int, float)， 但是不能為fun(int, int)）；   
2、不能通過訪問許可權、返回型別、丟擲的異常進行過載；   
3、方法的異常型別和數目不會對過載造成影響；   
4、過載事件通常發生在同一個類中，不同方法之間的現象。 
5、存在於同一類中，但是隻有虛方法和抽象方法才能被覆寫。 

其具體實現機制： 

overload是過載，過載是一種引數多型機制，即程式碼通過引數的型別或個數不同而實現的多型機制。 是一種靜態的繫結機制（在編譯時已經知道具體執行的是哪個程式碼段）。   
    
override是覆蓋。覆蓋是一種動態繫結的多型機制。即在父類和子類中同名元素（如成員函式）有不同 的實現程式碼。執行的是哪個程式碼是根據執行時實際情況而定的。 

Overrride例項 ：

1. class A{     
2. public int getVal(){     
3.    return(5);     
4. }     
5. }     
6. class B extends A{     
7. public int getVal(){     
8.    return(10);     
9. }     
10. }     
11. public class override {     
12. public static void main(String[] args) {     
13.    B b = new B();     
14.    A a= (A)b;//把 b 強 制轉換成A的型別     
15.    int x=a.getVal();     
16.    System.out.println(x);     
17. }     
18. }   

 結果：10 

Overload例項：

1. //Demostrate method voerloading.     
2. class OverloadDemo {     
3. void test(){     
4.    System.out.println("NO parameters");     
5. }     
6. void test(int a){     
7.    System.out.println("a:"+a);     
8. }//end of Overload test for one integer parameter.     
9. void test(int a, int b){     
10.    System.out.println("a and b:"+a+" "+b);     
11. }  
12. double test(double a){     
13.    System.out.println("double a:"+a);     
14.    return a*a;     
15. }  
16. }  
17. public class Overload{     
18. public static void main(String[] args) {     
19.    OverloadDemo ob = new OverloadDemo();     
20.    double result;     
21.    ob.test();     
22.    ob.test(10);     
23.    ob.test(10, 20);     
24.    result = ob.test(123.25);     
25.    System.out.println("Result of ob.test(123.25):"+result);  
26. }  
27. }  

 結果: 

NO parameters 
a:10 
a and b:10 20 
double a:123.25 
Result of ob.test(123.25):15190.5625