关于重写重载的区别探究

Java 允许在同一个类中定义多个具有相同名称的方法，只要它们具有不同的参数列表即可。 如果同一个类包含两个或多个方法名相同但参数列表不同的方法，则称为方法重载。

例如，在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

1. public void println(int i){…}
2. public void println(double d){…}
3. public void println(String s){…}

这些方法执行类似的功能，都是格式化输出。根据不同的格式和输出的参数来区分它们。它们构成方法重载。实际调用时，根据实际参数的类型确定调用哪个方法。例如：
System.out.println(102); // 调用 println(int i) 方法
System.out.println(102.25); // 调用 println(double d) 方法
System.out.println("价格为102.25"); // 调用 println(String s) 方法

方法重载的要求是两个不同的：同一个类中的方法名相同，参数列表不同。至于方法的其他部分，如方法返回类型、修饰符等，与方法重载无关。

使用方法重载其实是为了避免大量的方法名。一些方法具有类似的功能。如果重新创建方法并重新命名方法，会降低程序的可读性。

例 1

在比较数值时，数值的个数和类型是不固定的，可能是两个 int 类型的数值，也可能是两个 double 类型的数值，或者是两个 double、一个 int 类型的数值；在这种情况下就可以使用方法的重载来实现数值之间的比较功能。具体实现代码如下：

1. public class OverLoading {
2. public void max(int a, int b) {
3. // 含有两个int类型参数的方法
4. System.out.println(a > b ? a : b);
5. }
7. public void max(double a, double b) {
8. // 含有两个double类型参数的方法
9. System.out.println(a > b ? a : b);
10. }
12. public void max(double a, double b, int c) {
13. // 含有两个double类型参数和一个int类型参数的方法
14. double max = (double) (a > b ? a : b);
15. System.out.println(c > max ? c : max);
16. }
18. public static void main(String[] args) {
19. OverLoading ol = new OverLoading();
20. System.out.println("1 与 5 比较，较大的是：");
21. ol.max(1, 5);
22. System.out.println("5.205 与 5.8 比较，较大的是：");
23. ol.max(5.205, 5.8);
24. System.out.println("2.15、0.05、58 中，较大的是：");
25. ol.max(2.15, 0.05, 58);
26. }
27. }

　　编译运行上述程序是完全正常的。虽然这三个 max() 方法的方法名相同，但由于它们的形参列表不同，系统可以正常区分这三个方法。 Java虚拟机在运行时，根据传递的参数不同，调用不同的方法。结果如下：
比较 1 和 5，较大的是：

1 与 5 比较，较大的是：
5
5.205 与 5.8 比较，较大的是：
5.8
2.15、0.05、58 中，较大的是：
58.0

　　为什么不能通过方法的返回类型来区分方法重载？

对于int f(){}和void(){}这两种方法，if int result = f();这样调用，系统可以识别出返回值类型为int的方法被调用，但是Java在调用方法值的时候可以忽略方法返回，如果使用下面的方法调用f();，可以你判断调用的是哪个方法？如果还不能判断，Java系统也是一头雾水。编程中一个重要的经验法则是不要混淆系统，当系统混淆时，一定是你的错。因此，方法的返回类型不能作为Java中区分方法重载的依据。

　在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。当父类中的方法无法满足子类需求或子类具有特有功能的时候，需要方法重写。

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

在重写方法时，需要遵循下面的规则：

• 参数列表必须完全与被重写的方法参数列表相同。
• 返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）。
• 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。
• 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。

另外还要注意以下几条：

• 重写的方法可以使用 @Override 注解来标识。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够再次声明。
• 构造方法不能被重写。
• 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。
• 如果不能继承一个方法，则不能重写这个方法。

例 1

每种动物都有名字和年龄属性，但是喜欢吃的食物是不同的，比如狗喜欢吃骨头、猫喜欢吃鱼等，因此每种动物的介绍方式是不一样的。

下面编写 Java 程序，在父类 Animal 中定义 getInfo() 方法，并在子类 Cat 中重写该方法， 实现猫的介绍方式。父类 Animal 的代码如下：

1. public class Animal {
2. public String name; // 名字
3. public int age; // 年龄
5. public Animal(String name, int age) {
6. this.name = name;
7. this.age = age;
8. }
10. public String getInfo() {
11. return "我叫" + name + "，今年" + age + "岁了。";
12. }
13. }

子类 Cat 的代码如下：

1. public class Cat extends Animal {
2. private String hobby;
4. public Cat(String name, int age, String hobby) {
5. super(name, age);
6. this.hobby = hobby;
7. }
9. public String getInfo() {
10. return "喵！大家好！我叫" + this.name + "，我今年" + this.age + "岁了，我爱吃" + hobby + "。";
11. }
13. public static void main(String[] args) {
14. Animal animal = new Cat("小黄", 2, "草");
15. System.out.println(animal.getInfo());
16. }
17. }

如上述代码，在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法，而 Cat 类继承自该类，因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。但是我们在 Cat 类中又重新定义了一个 getInfo() 方法，即重写了父类中的 getInfo() 方法。

在 main() 方法中，创建了 Cat 类的对象 animal，并调用了 getInfo() 方法。输出的结果如下：

喵！大家好！我叫小黄，我今年2岁了，我爱吃草。

如果子类中创建了一个成员变量，而该变量的类型和名称都与父类中的同名成员变量相同，我们则称作变量隐藏。