The difference between override and overload override和overload 的区别

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);
       
       
    }
}
输出结果：
InstrumentX.play()
WindM.play(int n)
InstrumentX.play()

分析：对于类WindX显然是过载，因为返回值一样，只是参数类型不一样（如果是参数个数，顺序不一样，肯定也行的）
　　　对于类WindM显然是重写，因为返回值一样，并且参数类型，个数，顺序一样　　　
　　　对于类WindY实在不好下结论，因为类WindZ己经报语法错误了，显然重载是不能以返回值来区分的，正好印证了上面的话，所以实在不好说WindY到底是属于过载还是其它什么东西