一、方法的重載

　　重載就是根據不同的數據類型，自動匹配對應的方法。重載在編譯的時候就決定調用哪個方法了，和重寫不一樣。（常見，構造函數重載）。

舉個栗子：

1、基本數據類型的重載：

 1 /**
 2  * @author 薛定諤的貓
 3  * 基本數據類型的重載
 4  * */
 5 public class Main {
 6     
 7     static void methed( byte b) {
 8         System.out.println("byte:method");
 9     }
10     
11     static void method(double
 
 d) {
12         System.out.println("double:method");
13     }
14     
15     static void method(int i) {
16         System.out.println("int:method");
17     }
18     
19     static void method(String s) {
20         System.out.println("String:method");
21     }
22     
23     public static void main(String[] args) {
 
24         methed((byte)1);
25         method(2.0);
26         method(1);
27         method("zpoor");
28     }
29 }
30 
31 /*
32  * 結果：
33  *         byte:method
34  *        double:method
35  *        int:method
36  *        String:method
37 */

2、帶對象引用參數的重載

 1 /**
 2  * @author 薛定諤的貓
 3  * 帶有對象引用參數的重載
 
*/
 4 class Animal {
 5     
 6 }
 7 
 8 class Pig extends Test{
 9     
10 }
11 
12 class Test {
13     static void method(Test a) {
14         System.out.println("Animal");
15     }
16     
17     static void method(Pig p) {
18         System.out.println("Pig");
19     }
20     
21     public static void main(String[] args) {
22         Test a = new Test();
23         Pig p = new Pig();
24         Test b = new Pig();
25         
26         method(a);
27         method(p);
28         method(b);//為啥不是Pig，而是Animal
29         /*
30          * 盲目分析：看的是引用類型而不是對象類型，重載在編譯時候就決定了，
31          *             引用類型決定了哪個重載方法。
32          * */
33         
34     }
35 }
36 
37 /**
38  * 結果：
39  *     Animal
40     Pig
41     Animal
42 */

總結：重載的規則

1、重載的方法必須改變參數列表，參數必須不同（參數的個數，參數的類型，參數的順序）

2、被重載的方法與返回值沒有關系，不是通過返回值類型來判斷方法是不是重載了。

3、重載的方法可以改變訪問修飾符。

4、重載的方法可以聲明新的或者更廣的建廠異常。

5、方法能夠在一個類或者一個子類中被重載。

二、方法的重寫

重寫只能出現在繼承關系中，只要父類的方法不是final修飾的，都可以重寫父類的方法。重寫的有點：能夠定義某個子類特有的特征。

舉個栗子：

 1 /**
 2  * @author 薛定諤的貓
 3  * 重載例子*/
 4 class Animal {
 5     public void eat() {
 6         System.out.println("吃點東西");
 7     } 
 8 }
 9 
10 class Horse extends Animal {
11     public void eat() {
12         System.out.println("吃點草");//實現重載
13         }
14 }

對於父類繼承的抽象方法，要麽子類是重寫該方法，要麽把子類也設為抽象子類。所以抽象方法可以說是必須重寫的方法。

重寫的意義：

　　重寫可以實現多態，用父類的引用來指向子類對象。

舉個栗子：

 1 /**
 2  * @author 薛定諤的貓
 3  * 重寫例子*/
 4 public class Test {
 5     public static void main(String[] args) {
 6         Animal p = new Pig();
 7         p.eat();
 8     }
 9 }
10 
11 
12 class Animal {
13     public void eat() {
14         System.out.println("吃點東西吧");
15     }
16 }
17 
18 class Pig extends Animal {
19     public void eat() {
20         System.out.println("吃點豬食beautiful");
21     }
22 }

重載原則：（盲目分析）：

　　使用了什麽引用，編譯器只會調用引用類所擁有的方法。如果調用子類特有的方法就會報錯。也就是說，編譯器只看引用；類型，不看對象類型。

重寫方法的規則：

1、重寫方法不能比被重寫方法限制有更要個的訪問限權。（但是可以更加寬泛，父類是包訪問，子類的重寫方法可以使public訪問權限，特別留意toSting()）

2、參數列表必須與被重寫的方法相同（重寫和重載的區別）

3、重寫返回類型必須與被重寫方法的返回類型相同

4、重寫方法不能拋出新的異常，或者比被重載方法聲明的檢查異常更廣的檢查異常。但是可以拋出更少，更有限或者不拋出異常

5、final修飾的方法不能被重寫

6、一個方法不能被繼承，則不能重寫他（比如被final修飾的類的方法，還有就是父類的private修飾的方法）

好了盲目分析完了，寫點代碼壓壓驚。

Java-重載、重寫（冷靜分析）