Java 方法重写（Function Override）全面解析

简介

在 Java 编程中，方法重写（Function Override）是一项重要的面向对象编程特性。它允许子类重新定义父类中已有的方法，以实现特定于子类的行为。通过方法重写，我们可以在保持接口一致性的同时，根据不同的子类需求提供不同的实现细节。本文将详细介绍 Java 方法重写的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用这一特性。

基础概念

定义

方法重写是指在子类中定义一个与父类中具有相同名称、参数列表和返回类型的方法。子类通过重写父类的方法，可以改变该方法的具体实现，以满足自身的特殊需求。

条件

方法签名相同：方法名、参数列表必须与父类中的方法完全一致。
返回类型兼容：子类重写方法的返回类型必须与父类中被重写方法的返回类型相同或者是其子类型（从 Java 5 开始支持协变返回类型）。
访问修饰符限制：子类重写方法的访问修饰符不能比父类中被重写方法的访问修饰符更严格。例如，如果父类方法是 protected，子类重写方法可以是 protected 或 public，但不能是 private。

示例代码

// 父类
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪汪");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 输出: 汪汪汪
    }
}

在上述代码中，Dog 类继承自 Animal 类，并重写了 makeSound 方法。当我们创建一个 Dog 对象并将其赋值给 Animal 类型的引用时，调用 makeSound 方法会执行子类中重写后的方法。

使用方法

步骤

继承父类：子类需要继承包含被重写方法的父类。
重写方法：在子类中定义一个与父类中被重写方法具有相同名称、参数列表和返回类型的方法。
使用 @Override 注解：虽然 @Override 注解不是必需的，但建议使用它。该注解可以帮助编译器检查方法是否真的是重写父类的方法，如果不是，编译器会报错，从而避免一些潜在的错误。

代码示例

// 父类
class Shape {
    public double area() {
        return 0;
    }
}

// 子类
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        System.out.println("圆的面积: " + circle.area()); // 输出: 圆的面积: 78.53981633974483
    }
}

在上述代码中，Circle 类继承自 Shape 类，并重写了 area 方法，以计算圆的面积。

常见实践

实现多态

方法重写是实现多态的重要手段之一。多态允许我们通过父类引用调用子类的方法，从而实现代码的灵活性和可扩展性。

// 父类
class Vehicle {
    public void drive() {
        System.out.println("驾驶车辆");
    }
}

// 子类
class Car extends Vehicle {
    @Override
    public void drive() {
        System.out.println("驾驶汽车");
    }
}

class Motorcycle extends Vehicle {
    @Override
    public void drive() {
        System.out.println("驾驶摩托车");
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car();
        Vehicle motorcycle = new Motorcycle();

        car.drive(); // 输出: 驾驶汽车
        motorcycle.drive(); // 输出: 驾驶摩托车
    }
}

在上述代码中，我们通过父类 Vehicle 的引用调用子类 Car 和 Motorcycle 中重写的 drive 方法，实现了多态。

自定义异常处理

在自定义异常类中，我们可以重写 getMessage 方法，以提供更详细的异常信息。

class CustomException extends Exception {
    private String errorCode;

    public CustomException(String message, String errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    @Override
    public String getMessage() {
        return super.getMessage() + " (错误代码: " + errorCode + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            throw new CustomException("发生了自定义异常", "E001");
        } catch (CustomException e) {
            System.out.println(e.getMessage()); // 输出: 发生了自定义异常 (错误代码: E001)
        }
    }
}

在上述代码中，CustomException 类重写了 getMessage 方法，添加了错误代码信息。

最佳实践

遵循 Liskov 替换原则

Liskov 替换原则要求子类对象必须能够替换其父类对象，而不影响程序的正确性。在方法重写时，子类重写的方法应该保持与父类方法相同的行为契约，避免改变方法的预期行为。

合理使用 `super` 关键字

在子类重写的方法中，可以使用 super 关键字调用父类中被重写的方法。这在需要在子类中扩展父类方法的功能时非常有用。

// 父类
class Parent {
    public void printInfo() {
        System.out.println("这是父类的信息");
    }
}

// 子类
class Child extends Parent {
    @Override
    public void printInfo() {
        super.printInfo();
        System.out.println("这是子类额外的信息");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.printInfo();
        // 输出:
        // 这是父类的信息
        // 这是子类额外的信息
    }
}

在上述代码中，Child 类重写了 printInfo 方法，并使用 super.printInfo() 调用了父类的方法，然后添加了子类的额外信息。

小结

Java 方法重写是一项强大的面向对象编程特性，它允许子类重新定义父类中已有的方法，以实现特定于子类的行为。通过方法重写，我们可以实现多态，提高代码的灵活性和可扩展性。在使用方法重写时，需要遵循一定的条件和最佳实践，以确保代码的正确性和可维护性。

参考资料

《Effective Java》
Java 官方文档
《Java 核心技术》