【IT领域新生必看】 Java编程中的重写（Overriding）规则：初学者轻松掌握的全方位指南
【IT领域新生必看】 Java编程中的重写（Overriding）规则：初学者轻松掌握的全方位指南
引言
在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中的重写规则有了全面的了解。希望你在编程的学习过程中不断进步，成为一名出色的程序员！
无论你是在实现多态性、提供特定实现，还是改进父类方法，记住遵循重写的规则和最佳实践，这将使你的代码更加高效、可读和可靠。祝你编程愉快！
腾讯云开发者
