深入理解 Java 方法重写

简介

在 Java 面向对象编程中，方法重写（Method Overriding）是一个强大且重要的特性。它允许子类对从父类继承来的方法进行重新定义，从而实现根据子类的特定需求定制行为。通过方法重写，我们能够构建更加灵活、可扩展和易于维护的软件系统。本文将详细介绍 Java 方法重写的基础概念、使用方法、常见实践以及最佳实践，帮助你深入理解并熟练运用这一特性。

基础概念

定义

方法重写是指在子类中定义一个与父类中已有的方法具有相同名称、相同参数列表和相同返回类型（或者是返回类型的子类型，这在 Java 5.0 及更高版本中允许，称为协变返回类型）的方法。当子类对象调用这个重写的方法时，实际执行的是子类中定义的方法，而不是父类中的方法。

目的

方法重写的主要目的是实现多态性。通过多态，我们可以根据对象的实际类型来动态地调用相应的方法，从而使程序更加灵活和可扩展。例如，在一个图形绘制系统中，父类 Shape 可能定义了一个 draw 方法，而子类 Circle、Rectangle 等可以重写 draw 方法，以实现各自不同的绘制逻辑。

重写规则

方法签名必须相同：方法名、参数列表和返回类型（或者是返回类型的子类型）必须与父类中的方法一致。例如：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

在上述代码中，Dog 类重写了 Animal 类的 makeSound 方法，方法签名完全相同。

访问修饰符不能更严格：子类重写方法的访问修饰符不能比父类中被重写方法的访问修饰符更严格。例如，如果父类方法是 public，子类重写方法也必须是 public；如果父类方法是 protected，子类重写方法可以是 protected 或 public。
不能抛出新的受检异常或比父类方法更宽泛的受检异常：子类重写方法可以抛出与父类方法相同的受检异常，或者抛出父类方法所抛出受检异常的子类，也可以不抛出任何受检异常。但不能抛出新的受检异常或比父类方法更宽泛的受检异常。对于非受检异常（运行时异常）则没有此限制。

使用方法

基本步骤

创建父类和子类：定义一个父类，并在其中声明需要被子类重写的方法。然后创建一个子类，继承自父类。

class Vehicle {
    public void start() {
        System.out.println("Vehicle is starting");
    }
}

class Car extends Vehicle {
    // 这里将重写 start 方法
}

在子类中重写方法：在子类中定义一个与父类方法签名相同的方法，并实现子类特定的逻辑。

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car is starting with ignition");
    }
}

测试重写效果：创建子类对象，并调用重写的方法，观察实际执行的是子类中的方法。

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();
        myCar.start(); // 输出：Car is starting with ignition
    }
}

调用父类被重写的方法

在子类重写方法中，如果需要调用父类被重写的方法，可以使用 super 关键字。例如：

class Car extends Vehicle {
    @Override
    public void start() {
        super.start(); // 调用父类的 start 方法
        System.out.println("Car is starting with ignition");
    }
}

上述代码中，super.start() 会先执行父类 Vehicle 的 start 方法，然后再执行子类 Car 中额外的逻辑。

常见实践

多态性应用

方法重写是实现多态性的关键。通过创建一个父类引用指向子类对象，然后调用重写的方法，可以根据对象的实际类型动态地执行相应的方法。例如：

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();

        shape1.draw(); // 输出：Drawing a circle
        shape2.draw(); // 输出：Drawing a rectangle
    }
}

在上述代码中，shape1 和 shape2 都是 Shape 类型的引用，但分别指向 Circle 和 Rectangle 对象。调用 draw 方法时，实际执行的是子类中重写的方法，展示了多态性的效果。

框架中的方法重写

在许多 Java 框架中，方法重写被广泛应用。例如，在 Spring 框架中，我们可以通过重写 HttpServlet 中的方法来创建自定义的 Servlet。

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>Hello from MyServlet</h1>");
        out.println("</body></html>");
    }
}

在上述代码中，MyServlet 重写了 HttpServlet 的 doGet 方法，以处理 HTTP GET 请求并返回自定义的 HTML 内容。

最佳实践

遵循重写规则

始终严格遵循方法重写的规则，确保代码的正确性和可维护性。特别是在处理访问修饰符和异常时，要仔细检查，避免出现编译错误。

合理使用 `@Override` 注解

在子类重写方法时，建议使用 @Override 注解。这个注解可以让编译器检查该方法是否确实是重写了父类中的方法，如果拼写错误或方法签名不一致，编译器会给出错误提示，有助于早期发现问题。

class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bird chirps");
    }
}

保持方法的语义一致性

虽然子类可以根据自身需求重写方法，但尽量保持方法的语义与父类一致。例如，如果父类的 calculate 方法用于计算某个值，子类重写的 calculate 方法也应该执行类似的计算操作，只是可能采用不同的算法。这样可以提高代码的可读性和可维护性，让其他开发者更容易理解和使用代码。

考虑调用父类方法

在子类重写方法中，根据实际需求合理决定是否调用父类被重写的方法。如果子类的逻辑是在父类逻辑的基础上进行扩展，那么调用父类方法是一个不错的选择。但如果子类的逻辑与父类完全不同，可能就不需要调用父类方法。

小结

方法重写是 Java 面向对象编程中一个非常重要的特性，它为我们提供了实现多态性的能力，使代码更加灵活和可扩展。通过本文的介绍，我们深入了解了方法重写的基础概念、使用方法、常见实践以及最佳实践。在实际开发中，合理运用方法重写可以提高代码的质量和可维护性，帮助我们构建更加健壮和高效的软件系统。希望读者通过本文的学习，能够熟练掌握并运用 Java 方法重写这一强大的技术。

以上就是关于 Java 方法重写的详细介绍，希望对你有所帮助。如果你有任何问题或建议，欢迎在评论区留言。