什么是Java的重写
Java的重写(Override)是面向对象编程中多态性的重要体现，指的是子类对父类中允许访问的方法进行重新定义的过程。当子类需要改变父类方法的行为时，可以通过重写来实现，而不需要修改父类的源代码。
重写的基本语法
```java
class Parent {
public void show() {
System.out.println("Parent's show()");
}
}
class Child extends Parent {
@Override
public void show() {
System.out.println("Child's show()");
}
}
在这个例子中，Child类重写了Parent类的show()方法，当通过Child类实例调用show()时，将执行子类中的版本而非父类中的版本。
## Java重写与重载的区别
许多初学者容易混淆重写(Override)和重载(Overload)的概念，实际上它们是两个完全不同的机制：
| 特性 | 重写(Override) | 重载(Overload) |
|-----------|-----------------------------|-----------------------------|
| 作用范围 | 子类与父类之间 | 同一个类中 |
| 方法签名 | 必须完全相同 | 必须不同(参数类型、数量或顺序不同) |
| 返回类型 | 必须相同或为子类型 | 可以不同 |
| 访问修饰符 | 不能比父类方法更严格 | 可以任意 |
| 抛出异常 | 不能抛出比父类方法更多或更宽泛的检查异常 | 可以不同 |
## Java重写的核心规则
要正确实现Java方法的重写，必须遵循以下严格规则：
### 1. 方法签名必须完全一致
重写方法的方法名、参数列表必须与父类方法完全相同。任何参数类型、顺序或数量的差异都会导致方法重载而非重写。
### 2. 返回类型协变
从Java 5开始，重写方法的返回类型可以是父类方法返回类型的子类，这称为协变返回类型(Covariant Return Type)。
```java
class Animal {
public Animal reproduce() {
return new Animal();
}
}
class Dog extends Animal {
@Override
public Dog reproduce() { // 返回Dog而非Animal
return new Dog();
}
}
3. 访问修饰符限制
重写方法的访问权限不能比被重写方法更严格。例如：
- 父类方法是public，子类方法必须是public
- 父类方法是protected，子类方法可以是protected或public
4. 异常抛出限制
重写方法不能抛出比被重写方法更多或更宽泛的检查异常(checked exception)，但可以抛出更少、更具体的异常或不抛出异常。
@Override注解的重要性
在Java中，使用@Override注解虽然不是强制的，但强烈推荐，原因包括：
- 编译器检查：帮助编译器验证是否确实重写了父类方法，避免因拼写错误等原因意外创建新方法
- 代码可读性：明确标识出这是重写方法，提高代码可读性
- 维护便利：当父类方法改变时，带有@Override注解的子类方法会立即报错，提醒开发者同步修改
Java重写的实际应用场景
1. 多态性的实现
重写是实现运行时多态的关键机制。通过父类引用指向子类对象，并调用重写方法，可以实现"一个接口，多种实现"的效果。
class Animal {
public void sound() {
System.out.println("Animal makes sound");
}
}
class Dog extends Animal {
@Override
public void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
@Override
public void sound() {
System.out.println("Cat meows");
}
}
public class Test {
public static void main(String[] args) {
Animal myAnimal = new Animal();
Animal myDog = new Dog();
Animal myCat = new Cat();
myAnimal.sound(); // Animal makes sound
myDog.sound(); // Dog barks
myCat.sound(); // Cat meows
}
}
2. 框架中的模板方法模式
许多Java框架使用重写机制实现模板方法模式，定义算法的骨架，将某些步骤延迟到子类中实现。
abstract class Game {
// 模板方法，定义游戏流程
public final void play() {
initialize();
startPlay();
endPlay();
}
abstract void initialize();
abstract void startPlay();
abstract void endPlay();
}
class Cricket extends Game {
@Override
void initialize() {
System.out.println("Cricket Game Initialized");
}
@Override
void startPlay() {
System.out.println("Cricket Game Started");
}
@Override
void endPlay() {
System.out.println("Cricket Game Finished");
}
}
3. 自定义异常处理
通过重写Throwable类的方法，可以创建具有特殊行为的自定义异常。
class MyException extends Exception {
private String customMessage;
public MyException(String message) {
super(message);
this.customMessage = message;
}
@Override
public String getMessage() {
return "Custom: " + customMessage;
}
}
Java重写的高级话题
1. 静态方法的重写
静态方法不能被重写，因为它们是类级别的而非实例级别的。如果在子类中声明与父类相同的静态方法，这称为方法隐藏(Method Hiding)，而非重写。
class Parent {
public static void show() {
System.out.println("Parent's static show()");
}
}
class Child extends Parent {
public static void show() { // 方法隐藏，不是重写
System.out.println("Child's static show()");
}
}
2. final方法的重写限制
被声明为final的方法不能被子类重写，这通常用于防止关键方法被意外修改。
class Parent {
public final void show() {
System.out.println("This cannot be overridden");
}
}
class Child extends Parent {
// 编译错误：Cannot override the final method from Parent
// public void show() { ... }
}
3. 私有方法的重写
私有方法不能被重写，因为它们只在声明它们的类中可见。子类中定义的同名方法实际上是全新的方法，与父类方法无关。
重写的最佳实践
- 始终使用@Override注解：如前所述，这可以避免许多潜在错误
- 保持行为一致性：重写方法应该保持与父类方法相同的契约，避免让调用者感到意外
- 文档继承：使用JavaDoc的{@inheritDoc}标签继承父类方法的文档，并根据需要添加额外说明
- 考虑设计：如果发现需要大量重写父类方法，可能需要重新考虑类层次结构设计
- 性能考虑：重写方法通常会被JVM优化，但过度复杂的方法链可能会影响性能
常见问题与解决方案
1. 意外重载而非重写
常见错误是参数列表不完全匹配，导致创建了重载方法而非重写方法。解决方案是严格检查方法签名并使用@Override注解。
2. 访问修饰符冲突
尝试将重写方法的访问权限设置得比父类方法更严格会导致编译错误。解决方案是确保访问权限相同或更宽松。
3. 异常处理不当
重写方法抛出比父类方法更多的检查异常会导致编译错误。解决方案是只抛出相同或更具体的异常，或者使用运行时异常。
总结
Java的重写机制是面向对象编程的核心特性之一，它使得多态性成为可能，为代码提供了极大的灵活性和可扩展性。正确理解和应用重写规则，可以帮助开发者构建更加健壮、可维护的Java应用程序。记住重写与重载的区别，遵循重写的基本规则，并在实际开发中合理应用这一强大特性，将使你的Java编程水平更上一层楼。
