Java中Overload和Override的區別

override（重寫，覆蓋） 
1、方法名、參數、返回值相同。
2、子類方法不能縮小父類方法的訪問權限。
3、子類方法不能拋出比父類方法更多的異常(但子類方法可以不拋出異常)。
4、存在於父類和子類之間。
5、方法被定義爲final不能被重寫。

overload（重載，過載）
1、參數類型、個數、順序至少有一個不相同。  
2、不能重載只有返回值不同的方法名。
3、存在於父類和子類、同類中。

方法的重寫(Overriding)和重載(Overloading)是Java多態性的不同表現。

重寫(Overriding)是父類與子類之間多態性的一種表現，而重載(Overloading)是一個類中多態性的一種表現。

 

如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)

。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被"屏蔽"了.

 

如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型或有不同

的參數次序，則稱爲方法的重載(Overloading)。不能通過訪問權限、返回類型、拋出的異常

進行重載.

1. Override 特點

 1、覆蓋的方法的標誌必須要和被覆蓋的方法的標誌完全匹配，才能達到覆蓋的效果；
 2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
 3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
 4、被覆蓋的方法不能爲private，否則在其子類中只是新定義了一個方法，並沒有對其進行覆蓋。

2.Overload 特點

 1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int, float)， 但是不能爲fun(int, int)）；
 2、不能通過訪問權限、返回類型、拋出的異常進行重載；
 3、方法的異常類型和數目不會對重載造成影響；
 4、對於繼承來說，如果某一方法在父類中是訪問權限是priavte，那麼就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
　
A和B比較，當參數順序不一樣時，也可以
A和以C比較，當參數類型不一樣時，也可以
A和D比較，當參數個數不一樣時，也可以
A和E,F比較，當參數類型，順序或者個數不一樣時，返回值是可以不一樣的
A和G比較，當參數一樣時，返回值是不能不同的
   public void fun(String t, int i) {
        //A
    }
    public void fun(int i, String t) {
        //B
    }
    public void fun(int i, int t) {
        //C
        System.out.println("in (int ,int )");
    }
    public void fun(String t, int i, int c) {
        //D
    }
    public int fun(char t, int i) {
        //E
        System.out.println("in int fun");
        return 3;
    }
    public int fun(char t) {
        //F
        System.out.println("in int fun");
        return 3;
    }
  
//    public int fun(String t, int i) {//syntax error
//        //G
//        return 3;
//    }

再如下例

class NoteX {
    public static final int MIDDLE_C = 0, C_SHARP = 1, C_FLAT = 2;
}

class InstrumentX {
    public void play(int NoteX) {
        System.out.println("InstrumentX.play()");
    }
}

class WindX extends InstrumentX {
    public void play(NoteX n) {
        System.out.println("WindX.play(NoteX n)");
    }
}
class WindM extends InstrumentX {
    public void play(int n) {
        System.out.println("WindM.play(int n)");
    }
}
class WindY extends InstrumentX {
    public int play(NoteX n) {
        System.out.println("WindY.play(NoteX n)");
        return 1;
    }
}
//systax error
//class WindZ extends InstrumentX {
//    public int play(int n) {
//        System.out.println("WindZ.play(int n)");
//        return 1;
//    }
//}

public class WindError {
    public static void tune(InstrumentX i) {
        i.play(NoteX.MIDDLE_C);
    }

    public static void main(String[] args) {
        WindX flute = new WindX();
        tune(flute);
        WindM windm = new WindM();
        tune(windm);
        WindY windy = new WindY();
        tune(windy);
       
       
    }