Java 中的重写（Overriding）与重载（Overloading）

Anish Singh Walia 2022-10-01

重写（Overriding）和重载（Overloading）是 Java 编程中的核心概念。它们是我们在 Java 程序中实现多态性（Polymorphism）的方式。多态性是面向对象编程（OOP）的基本概念之一。

当超类（父类）和子类中的方法签名（方法名和参数）完全相同时，称为重写（Overriding）。
当同一个类中存在两个或多个方法名相同但参数不同的方法时，称为重载（Overloading）。

重写与重载对比

重写与重载示例

以下是一个包含重写和重载的 Java 程序示例：

package com.journaldev.examples;

import java.util.Arrays;

public class Processor {
    public void process(int i, int j) {
        System.out.printf("Processing two integers: %d, %d\n", i, j);
    }

    public void process(int[] ints) {
        System.out.println("Adding integer array: " + Arrays.toString(ints));
    }

    public void process(Object[] objs) {
        System.out.println("Adding integer array: " + Arrays.toString(objs));
    }
}

class MathProcessor extends Processor {
    @Override
    public void process(int i, int j) {
        System.out.println("Sum of integers is " + (i + j));
    }

    @Override
    public void process(int[] ints) {
        int sum = 0;
        for (int i : ints) {
            sum += i;
        }
        System.out.println("Sum of integer array elements is " + sum);
    }
}

重写（Overriding）

• Processor 类中的 process(int i, int j) 方法在子类 MathProcessor 中被重写（第 7 行 与 第 23 行）：

public class Processor {
    public void process(int i, int j) { /* ... */ }
}

class MathProcessor extends Processor {
    @Override
    public void process(int i, int j) { /* ... */ }
}

• Processor 类中的 process(int[] ints) 方法也在子类中被重写（第 11 行 与 第 28 行）：

public class Processor {
    public void process(int[] ints) { /* ... */ }
}

class MathProcessor extends Processor {
    @Override
    public void process(int[] ints) { /* ... */ }
}

注意：虽然 Processor 类还有一个 process(Object[] objs) 方法，但它没有被重写，因为 MathProcessor 中没有提供对应签名的实现。

重载（Overloading）

• Processor 类中对 process() 方法进行了三次重载（第 7、11、15 行）：

public class Processor {
    public void process(int i, int j) { /* ... */ }
    public void process(int[] ints) { /* ... */ }
    public void process(Object[] objs) { /* ... */ }
}

这三个方法具有相同的名称 process，但参数类型不同，因此构成了方法重载。

结论

本文介绍了 Java 中的重写与重载：

• 重写发生在父类与子类之间，要求方法签名完全一致，用于实现运行时多态。
• 重载发生在同一个类中，要求方法名相同但参数列表不同，用于实现编译时多态。