引言

在Java编程中，重写（Overriding）是一个重要的概念。它允许子类重新定义父类的方法，从而实现多态性和灵活的代码设计。理解并掌握重写规则，对于编写健壮和可维护的代码至关重要。对于初学者来说，了解重写的基本规则和最佳实践，是成为Java编程高手的关键一步。本篇文章将详细介绍Java中的重写规则，帮助你全面理解这一重要概念。

什么是方法重写（Overriding）？

方法重写是指子类提供了一个与父类在方法签名（包括方法名、参数类型和参数个数）完全相同的方法。重写的方法覆盖了父类的方法，从而使子类可以根据需要提供特定的实现。

方法重写的基本示例

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. 方法签名必须相同

重写的方法必须与被重写的方法具有相同的方法名、参数列表和返回类型。

示例：

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. 返回类型可以是子类型（协变返回类型）

重写的方法的返回类型可以是被重写方法返回类型的子类型。

示例：

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。

示例：

class Parent {
    public void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    @Override
    public void show() {
        System.out.println("Child");
    }
}

4. 不能抛出新的或更广泛的检查型异常

重写的方法不能抛出新的或更广泛的检查型异常，但可以抛出更少或更具体的异常。

示例：

class Parent {
    public void readFile() throws IOException {
        // 读取文件
    }
}

class Child extends Parent {
    @Override
    public void readFile() throws FileNotFoundException {
        // 读取文件
    }
}

在上述示例中，Child类的readFile方法抛出了更具体的异常FileNotFoundException，这是允许的。

5. 使用@Override注解

虽然@Override注解不是强制性的，但使用它可以帮助编译器检查方法是否正确地重写了父类的方法，从而避免一些常见错误。

示例：

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调用，而不是通过方法调用。

示例：

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. 实现多态性

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

示例：

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. 提供特定实现

通过重写，子类可以根据自己的需要提供特定的实现，而不是使用父类的通用实现。

示例：

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. 改进父类方法

子类可以重写父类的方法，以便改进或增强其功能。

示例：

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注解可以帮助编译器检查方法是否正确地重写了父类的方法，从而避免拼写错误或参数类型不匹配等问题。

示例：

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替换原则要求子类应该可以替换父类，并且程序的行为不会改变。重写方法时应确保不改变方法的预期行为。

示例：

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. 维护方法契约

重写的方法应该维护父类方法的契约，包括方法的签名、返回类型和抛出的异常。确保重写的方法在功能上与父类方法一致。

示例：

class Parent {
    public void process() throws IOException {
        // 处理逻辑
    }
}

class Child extends Parent {
    @Override
    public void process() throws FileNotFoundException {
        // 处理逻辑
    }
}

在上述示例中，Child类的process方法重写了父类的方法，并抛出了一个更具体的异常FileNotFoundException。

4. 避免过度重写

尽量避免过度重写父类的方法，保持代码简洁。如果父类的方法已经满足需求，不需要重写。

示例：

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中的重写规则有了全面的了解。希望你在编程的学习过程中不断进步，成为一名出色的程序员！

无论你是在实现多态性、提供特定实现，还是改进父类方法，记住遵循重写的规则和最佳实践，这将使你的代码更加高效、可读和可靠。祝你编程愉快！