深入分析Java中的重载与重写：理解多态的两个面向

之前其实写过一篇文章来探讨Java当中的方法重载与方法重写但当时学的还不够通透，分析有点片面，这次我从多态的角度对其进行分析，有问题欢迎大家来评论区一起探讨

在Java编程中，重载（Overloading）和重写（Overriding）是两种重要的面向对象特性，它们与多态密切相关。虽然这两者看似相似，但它们的实现方式、使用场景和多态类型完全不同。

1. 什么是重载与重写？

1.1 重载（Overloading）

重载是指在同一个类中可以定义多个方法，这些方法的名字相同但参数不同（包括参数类型、数量和顺序）。重载是在编译时决定的，也被称为静态多态。

1.2 重写（Overriding）

重写是指在子类中可以重写父类的方法，目的是提供子类特定的实现。重写是在运行时决定的，也被称为动态多态。

2. 重载与重写的关键区别

2.1 语法与实现

重载：

在同一个类中定义多个同名方法。
方法签名必须不同，参数类型、数量或顺序不同。

示例：

class MathUtils {
    public int add(int a, int b) {
        return a + b; // 重载方法：传入两个整数
    }

    public int add(int a, int b, int c) {
        return a + b + c; // 重载方法：传入三个整数
    }

    public double add(double a, double b) {
        return a + b; // 重载方法：传入两个双精度浮点数
    }
}

重写：

在子类中定义与父类相同签名的方法。
使用 @Override注解提高代码可读性和可维护性。

示例：

class Animal {
    public void sound() {
        System.out.println("Some generic animal sound");
    }
}

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

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

2.2 多态类型

重载：属于编译时多态，在编译阶段，根据传入参数决定调用哪个重载方法。
重写：属于运行时多态，在运行时根据对象的实际类型确定调用哪个方法。

2.3 目的

重载：提高代码的可读性，方便对同一功能的不同实现进行区分。
重写：实现父类和子类之间的行为多样性，允许子类根据自身特性来改变父类的方法实现。

3. 重载为什么是编译时多态？

重载被称为编译时多态的原因在于：

编译器决策：在编译阶段，编译器根据方法调用的参数类型、数量和顺序决定具体的重载方法。

示例分析：

public class Main {
    public static void main(String[] args) {
        MathUtils mathUtils = new MathUtils();
        System.out.println(mathUtils.add(5, 10));              // 调用 add(int, int)
        System.out.println(mathUtils.add(5, 10, 15));          // 调用 add(int, int, int)
        System.out.println(mathUtils.add(5.0, 10.0));          // 调用 add(double, double)
    }
}

4. 重写为什么是运行时多态？

重写被称为运行时多态的原因在于：

动态决策：在运行时，通过对象的实际类型确定方法调用。

示例分析：

public class Zoo {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound();  // 输出：Bark
        myCat.sound();  // 输出：Meow

        // 使用Animal数组来展示多态
        Animal[] animals = { new Dog(), new Cat() };
        for (Animal animal : animals) {
            animal.sound(); // 动态调用实际类型的方法
        }
    }
}

5. 实际应用场景

5.1 重载的应用

重载常用于参数不同的情况下，例如数学运算或格式化输出。

示例代码：计算区域

class ShapeUtils {
    public double area(double side) {
        return side * side; // 正方形
    }

    public double area(double length, double width) {
        return length * width; // 矩形
    }

    public double area(double radius, boolean isCircle) {
        if (isCircle) {
            return Math.PI * radius * radius; // 圆形
        }
        return 0;
    }
}

public class Main {
    public static void main(String[] args) {
        ShapeUtils shapeUtils = new ShapeUtils();
    
        System.out.println("Square Area: " + shapeUtils.area(5));              // 正方形
        System.out.println("Rectangle Area: " + shapeUtils.area(5, 10));      // 矩形
        System.out.println("Circle Area: " + shapeUtils.area(7, true));        // 圆形
    }
}

5.2 重写的应用

重写常用于需要实现多态性的场景，例如在动物园管理系统中。

示例代码：动物叫声

class Animal {
    public void sound() {
        System.out.println("Some generic animal sound");
    }
}

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

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Meow");
    }
}

public class Zoo {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
    
        myDog.sound();  // 输出：Bark
        myCat.sound();  // 输出：Meow

        Animal[] animals = { new Dog(), new Cat() };
        for (Animal animal : animals) {
            animal.sound(); // 动态调用实际类型的方法
        }
    }
}

6. 重载与重写的对比表

特性	重载（Overloading）	重写（Overriding）
定义	在同一类中定义同名但参数不同的方法	在子类中重写父类的方法
多态类型	编译时多态	运行时多态
方法签名	必须不同（参数类型、数量或顺序）	签名必须完全相同
适用场景	当需要同一个方法名的不同实现时	当子类需要特定实现时
使用注解	无需使用	通常使用 `@Override`注解