Java 方法的重载（Overloading）与重写（Overriding）：多态的实现基础

各位观众，各位来宾，大家好！欢迎来到“Java方法论”专场讲座。今天我们要聊聊Java这门语言中，两个非常重要，但又经常被新手朋友搞混的概念：方法重载（Overloading）和方法重写（Overriding）。它们就像一对双胞胎，长得有点像，但性格和用途却截然不同。理解了它们，你就掌握了Java多态性的精髓，通往武林高手的道路就打开了一半！

一、什么是多态？先打个比方

在深入重载和重写之前，咱们先聊聊“多态”。多态（Polymorphism）这个词听起来很高大上，但其实很简单，用大白话说就是“一个接口，多种实现”。

想象一下，你养了一只宠物，你对它说：“叫！”

如果你养的是一只小狗，它会“汪汪”叫。
如果你养的是一只小猫，它会“喵喵”叫。
如果你养的是一只小鸡，它会“咯咯”叫。

同一个指令“叫！”，不同的宠物却有不同的反应。这就是多态！

在Java中，多态是指允许不同类的对象对同一消息做出不同的响应。多态性是面向对象编程的三大特征之一（封装、继承、多态），它极大地提高了代码的灵活性和可扩展性。

二、方法重载（Overloading）：一招多式，名称相同，参数不同

方法重载是指在一个类中定义多个同名的方法，但这些方法的参数列表必须不同。参数列表的不同体现在以下几个方面：

参数的类型不同
参数的个数不同
参数的顺序不同（这种情况比较少见，但也是合法的）

重点： 方法重载与方法的返回值类型无关。也就是说，即使两个方法的参数列表完全相同，但返回值类型不同，它们也不是重载关系，而是编译错误。

我们可以把方法重载理解为武侠小说中的“一招多式”。同样是“降龙十八掌”，乔峰可以根据不同的情况，选择不同的掌法来应对。

代码示例：

public class Calculator {

    // 两个整数相加
    public int add(int a, int b) {
        System.out.println("执行add(int a, int b)");
        return a + b;
    }

    // 三个整数相加
    public int add(int a, int b, int c) {
        System.out.println("执行add(int a, int b, int c)");
        return a + b + c;
    }

    // 两个浮点数相加
    public double add(double a, double b) {
        System.out.println("执行add(double a, double b)");
        return a + b;
    }

    // 整数和浮点数相加
    public double add(int a, double b) {
        System.out.println("执行add(int a, double b)");
        return a + b;
    }

    // 浮点数和整数相加
    public double add(double a, int b) {
        System.out.println("执行add(double a, int b)");
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        System.out.println(calculator.add(1, 2));       // 输出: 3  执行add(int a, int b)
        System.out.println(calculator.add(1, 2, 3));    // 输出: 6  执行add(int a, int b, int c)
        System.out.println(calculator.add(1.5, 2.5));  // 输出: 4.0 执行add(double a, double b)
        System.out.println(calculator.add(1, 2.5));    // 输出: 3.5 执行add(int a, double b)
        System.out.println(calculator.add(1.5, 2));    // 输出: 3.5 执行add(double a, int b)
    }
}

在这个例子中，Calculator类定义了多个名为add的方法，但它们的参数列表各不相同。当我们调用add方法时，编译器会根据我们传入的参数类型和个数，自动选择最匹配的方法来执行。这就是方法重载的魅力！

方法重载的优点：

提高代码的可读性： 使用相同的名称来表示相似的功能，更容易理解和记忆。
提高代码的灵活性： 可以根据不同的输入参数，执行不同的操作。
减少代码的冗余： 避免为相似的功能编写多个名称不同的方法。

方法重载的注意事项：

方法重载必须发生在同一个类中。
方法重载必须满足参数列表不同的条件。
方法重载与方法的返回值类型无关。
如果两个方法只有返回值类型不同，而参数列表完全相同，那么它们不是重载关系，而是编译错误。

三、方法重写（Overriding）：青出于蓝，继承父类，重塑行为

方法重写是指子类继承父类后，可以对父类中已有的方法进行修改或增强。重写的方法必须与父类中的方法具有相同的名称、参数列表和返回值类型。

重点： 方法重写必须发生在继承关系中。子类重写父类的方法，是为了改变或增强父类方法的行为。

我们可以把方法重写理解为武侠小说中的“青出于蓝”。徒弟继承了师傅的武功，但经过自己的修炼和领悟，可以使这门武功更加精妙，威力更强。

代码示例：

// 父类：动物
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类：狗
class Dog extends Animal {
    @Override // 这是一个注解，用于告诉编译器这是一个重写的方法
    public void makeSound() {
        System.out.println("狗发出汪汪汪的声音");
    }
}

// 子类：猫
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵喵的声音");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();

        animal.makeSound(); // 输出: 动物发出声音
        dog.makeSound();    // 输出: 狗发出汪汪汪的声音
        cat.makeSound();    // 输出: 猫发出喵喵喵的声音

        //多态的体现
        Animal animal1 = new Dog();
        animal1.makeSound(); // 输出: 狗发出汪汪汪的声音

        Animal animal2 = new Cat();
        animal2.makeSound(); // 输出: 猫发出喵喵喵的声音
    }
}

在这个例子中，Animal类有一个makeSound方法，用于表示动物发出声音。Dog和Cat类都继承了Animal类，并分别重写了makeSound方法，使其能够发出狗和猫的声音。

当我们调用dog.makeSound()时，实际上调用的是Dog类中重写后的makeSound方法，而不是Animal类中的makeSound方法。这就是方法重写的威力！

方法重写的优点：

实现多态性： 不同的子类可以对同一个方法做出不同的响应。
增强代码的可扩展性： 可以在不修改父类代码的情况下，扩展父类的功能。
提高代码的灵活性： 可以根据不同的需求，定制子类的行为。

方法重写的注意事项：

方法重写必须发生在继承关系中。
重写的方法必须与父类中的方法具有相同的名称、参数列表和返回值类型。
重写的方法的访问权限不能低于父类中被重写的方法的访问权限。（例如：父类方法是protected，子类重写的方法可以是protected或者public，但不能是private）
父类的final方法不能被重写。
父类的static方法不能被重写（但可以在子类中定义一个同名的static方法，这被称为隐藏）。
如果子类重写的方法抛出的异常类型比父类被重写的方法抛出的异常类型更宽泛，或者抛出了新的异常，那么编译时会报错。
可以使用@Override注解来显式地声明一个方法是重写的方法。这个注解可以帮助编译器检查是否正确地重写了父类的方法。

四、重载与重写的区别：一张表格来说清楚

为了更好地理解重载和重写，我们用一张表格来总结一下它们的主要区别：

特征	方法重载（Overloading）	方法重写（Overriding）
发生范围	同一个类中	父类与子类之间
关系	多个同名方法	子类对父类方法的修改或增强
参数列表	必须不同	必须相同
返回值类型	可以相同，也可以不同	必须相同
访问权限	没有限制	不能低于父类方法的访问权限
异常	没有限制	不能抛出更宽泛的异常或新的异常
目的	提供多个类似功能的方法，方便调用	改变或增强父类方法的行为
是否是多态性	编译时多态（静态多态）	运行时多态（动态多态）

五、多态的实现：重载与重写共同作用

方法重载和方法重写都是实现多态性的重要手段。

方法重载实现编译时多态（静态多态）： 编译器在编译时根据参数列表来确定调用哪个重载方法。
方法重写实现运行时多态（动态多态）： 在程序运行时，根据对象的实际类型来确定调用哪个重写方法。

运行时多态的例子：

在之前的Animal、Dog、Cat的例子中，

Animal animal1 = new Dog();
animal1.makeSound(); // 输出: 狗发出汪汪汪的声音

Animal animal2 = new Cat();
animal2.makeSound(); // 输出: 猫发出喵喵喵的声音

animal1和animal2都是Animal类型的引用，但它们分别指向Dog和Cat类型的对象。当我们调用animal1.makeSound()和animal2.makeSound()时，程序会根据animal1和animal2实际指向的对象类型，来决定调用哪个makeSound方法。这就是运行时多态的体现。

六、向上转型与向下转型

理解多态，离不开向上转型和向下转型这两个概念。

向上转型（Upcasting）： 将子类类型的对象赋值给父类类型的引用。这是一种安全的转型，不需要显式地进行类型转换。

例如：Animal animal = new Dog();

向上转型的好处是可以提高代码的通用性。我们可以使用父类类型的引用来操作子类对象，而不需要知道子类的具体类型。
向下转型（Downcasting）： 将父类类型的引用转换为子类类型的引用。这是一种不安全的转型，需要显式地进行类型转换，并且可能会抛出ClassCastException异常。

例如：Dog dog = (Dog) animal;

向下转型只有在父类引用实际指向的是子类对象时才是安全的。

代码示例：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 向上转型

        // 安全的向下转型
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.makeSound(); // 输出: 狗发出汪汪汪的声音
        }

        // 不安全的向下转型，会抛出ClassCastException
        Animal animal2 = new Animal();
        try {
            Dog dog2 = (Dog) animal2; // 运行时错误：ClassCastException
            dog2.makeSound();
        } catch (ClassCastException e) {
            System.out.println("类型转换失败：" + e.getMessage());
        }
    }
}

七、总结：重载与重写，多态的两翼

方法重载和方法重写是Java实现多态性的两个重要支柱。重载提供了在同一个类中定义多个具有相同名称但不同参数列表的方法的能力，实现了编译时多态；重写则允许子类修改或增强父类方法的行为，实现了运行时多态。

掌握了重载和重写，你就掌握了Java多态性的精髓，可以编写出更加灵活、可扩展和易于维护的代码。

希望今天的讲解对大家有所帮助。记住，编程之路，没有捷径，只有不断学习和实践！谢谢大家！

Java 方法的重载（Overloading）与重写（Overriding）：多态的实现基础

发表回复 取消回复

发表回复取消回复