Java方法重写(Override)深度解析：从语法细节到设计哲学
方法重写(Override)是Java面向对象编程中实现多态性的关键机制，也是继承体系中最核心的概念之一。本文将全面剖析方法重写的方方面面，包括语法规则、实现原理、使用场景以及常见误区，并通过丰富的代码示例展示方法重写的各种细节。
一、方法重写的基本概念
1.1 什么是方法重写？
方法重写是指子类重新定义父类中已经定义的方法，以改变或扩展该方法的行为。重写后的方法：
- 具有相同的方法签名（方法名+参数列表）
- 提供不同的方法实现
- 在运行时根据对象实际类型调用相应版本
1.2 方法重写 vs 方法重载
| 特性 | 方法重写(Override) | 方法重载(Overload) |
|---|---|---|
| 方法签名 | 必须相同 | 必须不同 |
| 返回类型 | 相同或协变 | 可以不同 |
| 访问修饰符 | 不能更严格 | 可以不同 |
| 抛出异常 | 不能更多或更宽 | 可以不同 |
| 调用方式 | 运行时确定（动态绑定） | 编译时确定（静态绑定） |
| 应用场景 | 父子类之间 | 同一类中 |
1.3 简单示例
class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
public Animal getOffspring() {
return new Animal();
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("汪汪汪");
}
@Override
public Dog getOffspring() { // 协变返回类型
return new Dog();
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Dog(); // 多态
myAnimal.makeSound(); // 输出"汪汪汪"
Animal offspring = myAnimal.getOffspring();
System.out.println(offspring.getClass()); // 输出"class Dog"
}
}
二、方法重写的详细规则
2.1 基本规则
- 方法签名必须完全相同（方法名和参数列表）
- 返回类型可以是父类方法返回类型的子类（协变返回类型，Java 5+）
- 访问修饰符不能比父类方法更严格：
- 父类public → 子类必须public
- 父类protected → 子类protected或public
- 父类默认(包私有) → 子类不能是private
- 不能抛出比父类方法更多的检查异常（可以抛出更少或子类异常）
- 不能重写final、static或private方法
2.2 协变返回类型（Covariant Return Type）
Java 5开始支持协变返回类型，允许重写方法返回父类方法返回类型的子类：
class Fruit {
protected Number getWeight() {
return 100;
}
}
class Apple extends Fruit {
@Override
public Integer getWeight() { // Integer是Number的子类
return 150;
}
}
2.3 异常处理规则
class Parent {
protected void process() throws IOException {
// ...
}
}
class ValidChild extends Parent {
@Override
protected void process() throws FileNotFoundException { // FileNotFoundException是IOException的子类
// ...
}
}
class InvalidChild extends Parent {
@Override
protected void process() throws Exception { // 编译错误：Exception比IOException更宽
// ...
}
}
2.4 @Override注解
@Override注解不是必须的，但强烈建议使用：
- 帮助编译器检查是否确实重写了父类方法
- 提高代码可读性
- 防止因拼写错误导致意外创建新方法
class Bird {
public void fly() {
System.out.println("鸟儿飞翔");
}
}
class Penguin extends Bird {
@Override
public void fly() {
System.out.println("企鹅不会飞");
}
// 如果没有@Override，下面的拼写错误不会被发现
// public void flay() { // 本意是重写fly，但拼写错误
// System.out.println("拼写错误的方法");
// }
}
三、方法重写的实现原理
3.1 虚方法表（Virtual Method Table）
JVM通过虚方法表实现动态绑定：
- 每个类都有一个虚方法表
- 表中存放着方法的实际入口地址
- 子类方法表中：
- 重写的方法指向子类实现
- 未重写的方法指向父类实现
Animal虚方法表：
+-------------------+-------------------+
| 方法签名 | 实际地址 |
+-------------------+-------------------+
| makeSound() | Animal.makeSound()|
| getOffspring() | Animal.getOffspring()|
+-------------------+-------------------+
Dog虚方法表：
+-------------------+-------------------+
| 方法签名 | 实际地址 |
+-------------------+-------------------+
| makeSound() | Dog.makeSound() |
| getOffspring() | Dog.getOffspring()|
+-------------------+-------------------+
3.2 静态绑定 vs 动态绑定
- 静态绑定：编译时确定方法调用（private、static、final方法和字段访问）
- 动态绑定：运行时根据对象实际类型确定方法调用（实例方法的重写）
class BindingExample {
static class Parent {
String field = "父类字段";
static void staticMethod() {
System.out.println("父类静态方法");
}
final void finalMethod() {
System.out.println("父类final方法");
}
void dynamicMethod() {
System.out.println("父类动态方法");
}
}
static class Child extends Parent {
String field = "子类字段";
static void staticMethod() {
System.out.println("子类静态方法");
}
// 不能重写final方法
@Override
void dynamicMethod() {
System.out.println("子类动态方法");
}
}
public static void main(String[] args) {
Parent obj = new Child();
System.out.println(obj.field); // 输出"父类字段"（静态绑定）
obj.staticMethod(); // 输出"父类静态方法"（静态绑定）
obj.finalMethod(); // 输出"父类final方法"（静态绑定）
obj.dynamicMethod(); // 输出"子类动态方法"（动态绑定）
}
}
四、方法重写的特殊场景
4.1 静态方法"重写"
静态方法不能被重写，只能被隐藏：
class StaticParent {
static void show() {
System.out.println("父类静态方法");
}
}
class StaticChild extends StaticParent {
static void show() { // 不是重写，是隐藏
System.out.println("子类静态方法");
}
}
public class Test {
public static void main(String[] args) {
StaticParent parent = new StaticChild();
parent.show(); // 输出"父类静态方法"（编译时类型决定）
StaticChild child = new StaticChild();
child.show(); // 输出"子类静态方法"
}
}
4.2 私有方法重写
私有方法不能被重写，子类中相同签名的方法实际上是新方法：
class PrivateParent {
private void secret() {
System.out.println("父类私有方法");
}
public void callSecret() {
secret();
}
}
class PrivateChild extends PrivateParent {
// 这不是重写，而是新方法
private void secret() {
System.out.println("子类私有方法");
}
public void callChildSecret() {
secret();
}
}
public class Test {
public static void main(String[] args) {
PrivateChild child = new PrivateChild();
child.callSecret(); // 输出"父类私有方法"
child.callChildSecret(); // 输出"子类私有方法"
}
}
4.3 构造方法中的重写陷阱
在构造方法中调用可重写方法是危险的做法：
class ConstructorParent {
ConstructorParent() {
printMessage(); // 危险：调用可重写方法
}
void printMessage() {
System.out.println("父类消息");
}
}
class ConstructorChild extends ConstructorParent {
private String message = "子类消息";
@Override
void printMessage() {
System.out.println(message); // 此时message还未初始化
}
}
public class Test {
public static void main(String[] args) {
new ConstructorChild(); // 输出"null"而非"子类消息"
}
}
问题原因：父类构造方法执行时，子类字段还未初始化
解决方案：
- 避免在构造方法中调用可重写方法
- 如果必须调用，将方法声明为final或private
五、方法重写的最佳实践
5.1 遵循里氏替换原则(LSP)
子类重写方法时应当：
- 不改变父类方法的契约（前置条件、后置条件、不变式）
- 不强加新的异常要求
- 不削弱父类方法的承诺
反面例子：
class Account {
/**
* 从账户取款
* @param amount 取款金额，必须>0
* @return 取款后的余额
* @throws IllegalArgumentException 如果amount<=0
*/
BigDecimal withdraw(BigDecimal amount) {
if (amount.compareTo(BigDecimal.ZERO) <= 0) {
throw new IllegalArgumentException("取款金额必须大于0");
}
// 实现逻辑
}
}
// 违反LSP的重写
class OverdraftAccount extends Account {
@Override
BigDecimal withdraw(BigDecimal amount) {
// 允许amount<=0（违反前置条件）
// 可能返回负余额（违反后置条件）
// 实现逻辑
}
}
5.2 使用模板方法模式
合理利用重写实现模板方法模式：
abstract class Beverage {
// 模板方法（final防止子类改变算法骨架）
final void prepare() {
boilWater();
brew();
pourInCup();
addCondiments();
}
abstract void brew();
abstract void addCondiments();
void boilWater() {
System.out.println("烧水");
}
void pourInCup() {
System.out.println("倒入杯子");
}
}
class Coffee extends Beverage {
@Override
void brew() {
System.out.println("冲泡咖啡粉");
}
@Override
void addCondiments() {
System.out.println("加糖和牛奶");
}
}
class Tea extends Beverage {
@Override
void brew() {
System.out.println("浸泡茶叶");
}
@Override
void addCondiments() {
System.out.println("加柠檬");
}
}
5.3 文档化重写方法
使用JavaDoc的{@inheritDoc}标签继承父类文档：
class DocumentedParent {
/**
* 执行重要操作
* @param input 输入参数，不能为null
* @return 操作结果，总是正数
* @throws NullPointerException 如果input为null
*/
public int importantOperation(String input) {
// 实现
}
}
class DocumentedChild extends DocumentedParent {
@Override
/**
* {@inheritDoc}
* @return 结果范围扩大到所有整数
*/
public int importantOperation(String input) {
// 实现
}
}
六、经典案例：Java集合框架中的重写
6.1 equals和hashCode的重写
class Person {
private final String name;
private final int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return age == person.age && name.equals(person.name);
}
@Override
public int hashCode() {
return 31 * name.hashCode() + age;
}
}
重写规则：
- 总是同时重写equals和hashCode
- equals要满足自反性、对称性、传递性、一致性
- 相等的对象必须有相同的hashCode
6.2 toString的重写
class Point {
private final int x;
private final int y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public String toString() {
return String.format("Point[x=%d, y=%d]", x, y);
}
}
七、常见面试问题解析
7.1 重写和重载的区别？
（见本文1.2节对比表）
7.2 能否重写静态方法？
不能，静态方法属于类而非实例，子类中的同名静态方法只是隐藏了父类方法。
7.3 构造方法能否被重写？
不能，构造方法不是普通方法，子类构造方法必须通过super调用父类构造方法。
7.4 重写时返回类型可以不同吗？
可以，但必须是协变返回类型（子类方法返回父类方法返回类型的子类）。
八、总结
方法重写是Java多态性的核心实现机制，正确理解和运用方法重写需要注意：
- 语法规则：签名相同、访问不更严、异常不更宽、返回类型协变
- 实现原理：虚方法表实现动态绑定
- 特殊场景：静态方法隐藏、私有方法新定义、构造方法陷阱
- 最佳实践：遵循LSP、使用模板方法、完整文档化
- 常见应用：equals/hashCode/toString重写、集合框架扩展
记住Josh Bloch在《Effective Java》中的建议："谨慎设计可被重写的方法，并文档化它们的实现要求"。合理使用方法重写可以创建出灵活、可扩展的系统，而滥用重写则会导致代码脆弱难维护。
