不再混淆！深度解析Java中的重写和重载

大家好，我是小欧！
今天我们来聊聊Java中的两个重要概念——重写（Override）和重载（Overload）。相信很多初学者在学习Java时都会被这两个看似相似的术语搞得一头雾水。那么，今天我们就来深入解析一下这两个概念，帮助大家不再混淆。

一、重写（Override）

什么是重写？

重写是指在子类中重新定义父类中的方法。换句话说，当子类继承父类时，可以对父类的方法进行重新实现，从而实现不同的功能。

重写的规则

1. 方法名、参数列表必须相同。
2. 返回类型必须相同，或是其子类型（协变返回类型）。
3. 访问修饰符不能比父类方法的访问修饰符更严格（例如，父类方法是public，子类方法不能是protected）。
4. 只能重写非静态方法，静态方法不能被重写。

代码示例

我们来看一个简单的例子：

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方法。当我们创建一个Dog对象并调用makeSound方法时，输出的结果是“Dog barks”。

注意事项

• 重写的方法必须带有@Override注解，这样编译器会帮我们检查是否确实进行了重写。
• 父类方法的异常声明也会影响重写，子类方法声明的异常不能超过父类方法的异常范围。

二、重载（Overload）

什么是重载？

重载是指在同一个类中定义多个方法，这些方法拥有相同的方法名，但参数列表不同（参数个数或类型不同）。重载是编译时的行为，编译器根据方法的签名来决定调用哪个方法。

重载的规则

1. 方法名必须相同。
2. 参数列表必须不同（参数的个数或类型）。
3. 返回类型可以相同也可以不同。
4. 可以有不同的访问修饰符。

代码示例

来看一个重载的例子：

class MathUtils {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        MathUtils math = new MathUtils();
        System.out.println(math.add(2, 3));         // 输出：5
        System.out.println(math.add(2.5, 3.5));     // 输出：6.0
        System.out.println(math.add(1, 2, 3));      // 输出：6
    }
}

在这个例子中，MathUtils类有三个add方法，分别处理不同数量和类型的参数。编译器会根据我们传递的参数类型和个数来选择调用哪个add方法。

注意事项

• 重载与返回类型无关，仅通过返回类型不能区分重载的方法。
• 重载方法可以有不同的异常声明。

三、重写和重载的对比

为了更好地理解重写和重载，我们来进行一个简单的对比：

特点	重写（Override）	重载（Overload）
方法名	相同	相同
参数列表	必须相同	必须不同
返回类型	必须相同或是其子类型	可以相同也可以不同
访问修饰符	不能比父类方法更严格	可以不同
静态方法	不能重写	可以重载
注解	必须使用@Override	无需注解
编译时/运行时	运行时决定	编译时决定

四、实战案例

案例一：银行账户类

我们通过一个银行账户的例子来巩固一下重写和重载的概念。

class BankAccount {
    public void displayBalance() {
        System.out.println("Balance: $1000");
    }
}

class SavingsAccount extends BankAccount {
    @Override
    public void displayBalance() {
        System.out.println("Savings Account Balance: $1500");
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new SavingsAccount();
        account.displayBalance(); // 输出：Savings Account Balance: $1500
    }
}

案例二：计算器类

再来看一个计算器类的例子：

class Calculator {
    public int multiply(int a, int b) {
        return a * b;
    }

    public double multiply(double a, double b) {
        return a * b;
    }

    public int multiply(int a, int b, int c) {
        return a * b * c;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.multiply(2, 3));         // 输出：6
        System.out.println(calc.multiply(2.5, 3.5));     // 输出：8.75
        System.out.println(calc.multiply(1, 2, 3));      // 输出：6
    }
}

结语

希望通过今天的讲解，大家能更清晰地理解Java中的重写和重载。重写是为了子类能够重新定义父类的方法，实现多态性；而重载则是为了提高方法的灵活性，使同一个方法名可以处理不同类型或数量的参数。记住这些区别和规则，相信你在编写Java代码时会更加得心应手。关注我我们一起玩转Java！