引言在Java编程中，重写（Overriding）是一个重要的概念。它允许子类重新定义父类的方法，从而实现多态性和灵活的代码设计。理解并掌握重写规则，对于编写健壮和可维护的代码至关重要。对于初学者来说，了解重写的基本规则和最佳实践，是成为Java编程高手的关键一步。本篇文章将详细介绍Java中的重写规则，帮助你全面理解这一重要概念。
什么是方法重写（Overriding）？方法重写是指子类提供了一个与父类在方法签名（包括方法名、参数类型和参数个数）完全相同的方法。重写的方法覆盖了父类的方法，从而使子类可以根据需要提供特定的实现。
方法重写的基本示例代码语言：javascript复制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");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound(); // 输出：Dog barks
}
}在上述示例中，Dog类重写了Animal类的makeSound方法。当调用myDog.makeSound()时，执行的是Dog类中的实现，而不是Animal类中的实现。
方法重写的规则1. 方法签名必须相同重写的方法必须与被重写的方法具有相同的方法名、参数列表和返回类型。
示例：代码语言：javascript复制class Parent {
public void display(String message) {
System.out.println("Parent: " + message);
}
}
class Child extends Parent {
@Override
public void display(String message) {
System.out.println("Child: " + message);
}
}2. 返回类型可以是子类型（协变返回类型）重写的方法的返回类型可以是被重写方法返回类型的子类型。
示例：代码语言：javascript复制class Animal {
public Animal create() {
return new Animal();
}
}
class Dog extends Animal {
@Override
public Dog create() {
return new Dog();
}
}在上述示例中，Dog类的create方法返回Dog类型，这是Animal类型的子类型。
3. 访问修饰符不能比父类的更严格重写的方法不能具有更严格的访问权限。如果父类方法是public，那么子类方法也必须是public。
示例：代码语言：javascript复制class Parent {
public void show() {
System.out.println("Parent");
}
}
class Child extends Parent {
@Override
public void show() {
System.out.println("Child");
}
}4. 不能抛出新的或更广泛的检查型异常重写的方法不能抛出新的或更广泛的检查型异常，但可以抛出更少或更具体的异常。
示例：代码语言：javascript复制class Parent {
public void readFile() throws IOException {
// 读取文件
}
}
class Child extends Parent {
@Override
public void readFile() throws FileNotFoundException {
// 读取文件
}
}在上述示例中，Child类的readFile方法抛出了更具体的异常FileNotFoundException，这是允许的。
5. 使用@Override注解虽然@Override注解不是强制性的，但使用它可以帮助编译器检查方法是否正确地重写了父类的方法，从而避免一些常见错误。
示例：代码语言：javascript复制class Parent {
public void greet() {
System.out.println("Hello from Parent");
}
}
class Child extends Parent {
@Override
public void greet() {
System.out.println("Hello from Child");
}
}6. 构造方法不能被重写构造方法不能被重写，因为它们在类实例化时由JVM调用，而不是通过方法调用。
示例：代码语言：javascript复制class Parent {
public Parent() {
System.out.println("Parent constructor");
}
}
class Child extends Parent {
public Child() {
super();
System.out.println("Child constructor");
}
}在上述示例中，Child类不能重写Parent类的构造方法，但可以在自己的构造方法中调用super()来显式调用父类的构造方法。
方法重写的应用场景1. 实现多态性重写是实现多态性的重要手段。多态性允许我们通过父类引用调用子类的方法，从而实现更灵活和可扩展的代码。
示例：代码语言：javascript复制class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat meows");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
}
public class Main {
public static void main(String[] args) {
Animal myCat = new Cat();
Animal myDog = new Dog();
myCat.makeSound(); // 输出：Cat meows
myDog.makeSound(); // 输出：Dog barks
}
}2. 提供特定实现通过重写，子类可以根据自己的需要提供特定的实现，而不是使用父类的通用实现。
示例：代码语言：javascript复制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 Main {
public static void main(String[] args) {
Shape myCircle = new Circle();
Shape myRectangle = new Rectangle();
myCircle.draw(); // 输出：Drawing a circle
myRectangle.draw(); // 输出：Drawing a rectangle
}
}3. 改进父类方法子类可以重写父类的方法，以便改进或增强其功能。
示例：代码语言：javascript复制class Calculator {
public int add(int a, int b) {
return a + b;
}
}
class AdvancedCalculator extends Calculator {
@Override
public int add(int a, int b) {
int sum = super.add(a, b);
System.out.println("Sum is: " + sum);
return sum;
}
}
public class Main {
public static void main(String[] args) {
AdvancedCalculator calculator = new AdvancedCalculator();
calculator.add(3, 4); // 输出：Sum is: 7
}
}重写的最佳实践1. 始终使用@Override注解使用@Override注解可以帮助编译器检查方法是否正确地重写了父类的方法，从而避免拼写错误或参数类型不匹配等问题。
示例：代码语言：javascript复制class Parent {
public void display() {
System.out.println("Parent display");
}
}
class Child extends Parent {
@Override
public void display() {
System.out.println("Child display");
}
}2. 遵循Liskov替换原则Liskov替换原则要求子类应该可以替换父类，并且程序的行为不会改变。重写方法时应确保不改变方法的预期行为。
示例：代码语言：javascript复制class Bird {
public void fly() {
System.out.println("Bird is flying");
}
}
class Penguin extends Bird {
@Override
public void fly() {
throw new UnsupportedOperationException("Penguins can't fly");
}
}在上述示例中，Penguin类违反了Liskov替换原则，因为它不能替换Bird类。
3. 维护方法契约重写的方法应该维护父类方法的契约，包括方法的签名、返回类型和抛出的异常。确保重写的方法在功能上与父类方法一致。
示例：代码语言：javascript复制class Parent {
public void process() throws IOException {
// 处理逻辑
}
}
class Child extends Parent {
@Override
public void process() throws FileNotFoundException {
// 处理逻辑
}
}在上述示例中，Child类的process方法重写了父类的方法，并抛出了一个更具体的异常FileNotFoundException。
4. 避免过度重写尽量避免过度重写父类的方法，保持代码简洁。如果父类的方法已经满足需求，不需要重写。
示例：代码语言：javascript复制class Vehicle {
public void start() {
System.out.println("Vehicle is
starting");
}
}
class Car extends Vehicle {
@Override
public void start() {
super.start(); // 保持父类行为
System.out.println("Car is starting");
}
}总结重写（Overriding）是Java编程中一个强大的功能，它允许子类重新定义父类的方法，从而实现多态性和灵活的代码设计。通过本文的介绍，你应该对Java中的重写规则有了全面的了解。希望你在编程的学习过程中不断进步，成为一名出色的程序员！
无论你是在实现多态性、提供特定实现，还是改进父类方法，记住遵循重写的规则和最佳实践，这将使你的代码更加高效、可读和可靠。祝你编程愉快！